Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://webaudio.github.io/web-audio-api/ below:

Web Audio API 1.1

Audio on the web has been fairly primitive up to this point and until very recently has had to be delivered through plugins such as Flash and QuickTime. The introduction of the audio element in HTML5 is very important, allowing for basic streaming audio playback. But, it is not powerful enough to handle more complex audio applications. For sophisticated web-based games or interactive applications, another solution is required. It is a goal of this specification to include the capabilities found in modern game audio engines as well as some of the mixing, processing, and filtering tasks that are found in modern desktop audio production applications.

The APIs have been designed with a wide variety of use cases [webaudio-usecases] in mind. Ideally, it should be able to support any use case which could reasonably be implemented with an optimized C++ engine controlled via script and run in a browser. That said, modern desktop audio software can have very advanced capabilities, some of which would be difficult or impossible to build with this system. Apple’s Logic Audio is one such application which has support for external MIDI controllers, arbitrary plugin audio effects and synthesizers, highly optimized direct-to-disk audio file reading/writing, tightly integrated time-stretching, and so on. Nevertheless, the proposed system will be quite capable of supporting a large range of reasonably complex games and interactive applications, including musical ones. And it can be a very good complement to the more advanced graphics features offered by WebGL. The API has been designed so that more advanced capabilities can be added at a later time.

The API supports these primary features:

• Modular routing for simple or complex mixing/effect architectures.

• High dynamic range, using 32-bit floats for internal processing.

• Sample-accurate scheduled sound playback with low latency for musical applications requiring a very high degree of rhythmic precision such as drum machines and sequencers. This also includes the possibility of dynamic creation of effects.

• Automation of audio parameters for envelopes, fade-ins / fade-outs, granular effects, filter sweeps, LFOs etc.

• Flexible handling of channels in an audio stream, allowing them to be split and merged.

• Processing of audio sources from an audio or video media element.

• Processing live audio input using a MediaStream from getUserMedia().

• Integration with WebRTC

  • Processing audio received from a remote peer using a MediaStreamTrackAudioSourceNode and [webrtc].

  • Sending a generated or processed audio stream to a remote peer using a MediaStreamAudioDestinationNode and [webrtc].

• Audio stream synthesis and processing directly using scripts.

• Spatialized audio supporting a wide range of 3D games and immersive environments:

  • Panning models: equalpower, HRTF, pass-through

  • Distance Attenuation

  • Sound Cones

  • Obstruction / Occlusion

  • Source / Listener based

• A convolution engine for a wide range of linear effects, especially very high-quality room effects. Here are some examples of possible effects:

  • Small / large room

  • Cathedral

  • Concert hall

  • Cave

  • Tunnel

  • Hallway

  • Forest

  • Amphitheater

  • Sound of a distant room through a doorway

  • Extreme filters

  • Strange backwards effects

  • Extreme comb filter effects

• Dynamics compression for overall control and sweetening of the mix

• Efficient real-time time-domain and frequency-domain analysis / music visualizer support.

• Efficient biquad filters for lowpass, highpass, and other common filters.

• A Waveshaping effect for distortion and other non-linear effects

• Oscillators

Modular routing allows arbitrary connections between different AudioNode objects. Each node can have inputs and/or outputs. A source node has no inputs and a single output. A destination node has one input and no outputs. Other nodes such as filters can be placed between the source and destination nodes. The developer doesn’t have to worry about low-level stream format details when two objects are connected together; the right thing just happens. For example, if a mono audio stream is connected to a stereo input it should just mix to left and right channels appropriately.

In the simplest case, a single source can be routed directly to the output. All routing occurs within an AudioContext containing a single AudioDestinationNode:

Illustrating this simple routing, here’s a simple example playing a single sound:

const context = new AudioContext();

function playSound() {
    const source = context.createBufferSource();
    source.buffer = dogBarkingBuffer;
    source.connect(context.destination);
    source.start(0);
}

Here’s a more complex example with three sources and a convolution reverb send with a dynamics compressor at the final output stage:

let context;let compressor;let reverb;let source1, source2, source3;let lowpassFilter;let waveShaper;let panner;let dry1, dry2, dry3;let wet1, wet2, wet3;let mainDry;let mainWet;function setupRoutingGraph () {    context = new AudioContext();    // Create the effects nodes.    lowpassFilter = context.createBiquadFilter();    waveShaper = context.createWaveShaper();    panner = context.createPanner();    compressor = context.createDynamicsCompressor();    reverb = context.createConvolver();    // Create main wet and dry.    mainDry = context.createGain();    mainWet = context.createGain();    // Connect final compressor to final destination.    compressor.connect(context.destination);    // Connect main dry and wet to compressor.    mainDry.connect(compressor);    mainWet.connect(compressor);    // Connect reverb to main wet.    reverb.connect(mainWet);    // Create a few sources.    source1 = context.createBufferSource();    source2 = context.createBufferSource();    source3 = context.createOscillator();    source1.buffer = manTalkingBuffer;    source2.buffer = footstepsBuffer;    source3.frequency.value = 440;    // Connect source1    dry1 = context.createGain();    wet1 = context.createGain();    source1.connect(lowpassFilter);    lowpassFilter.connect(dry1);    lowpassFilter.connect(wet1);    dry1.connect(mainDry);    wet1.connect(reverb);    // Connect source2    dry2 = context.createGain();    wet2 = context.createGain();    source2.connect(waveShaper);    waveShaper.connect(dry2);    waveShaper.connect(wet2);    dry2.connect(mainDry);    wet2.connect(reverb);    // Connect source3    dry3 = context.createGain();    wet3 = context.createGain();    source3.connect(panner);    panner.connect(dry3);    panner.connect(wet3);    dry3.connect(mainDry);    wet3.connect(reverb);    // Start the sources now.    source1.start(0);    source2.start(0);    source3.start(0);}

Modular routing also permits the output of AudioNodes to be routed to an AudioParam parameter that controls the behavior of a different AudioNode. In this scenario, the output of a node can act as a modulation signal rather than an input signal.

function setupRoutingGraph() {    const context = new AudioContext();    // Create the low frequency oscillator that supplies the modulation signal    const lfo = context.createOscillator();    lfo.frequency.value = 1.0;    // Create the high frequency oscillator to be modulated    const hfo = context.createOscillator();    hfo.frequency.value = 440.0;    // Create a gain node whose gain determines the amplitude of the modulation signal    const modulationGain = context.createGain();    modulationGain.gain.value = 50;    // Configure the graph and start the oscillators    lfo.connect(modulationGain);    modulationGain.connect(hfo.detune);    hfo.connect(context.destination);    hfo.start(0);    lfo.start(0);}

The interfaces defined are:

• An AudioContext interface, which contains an audio signal graph representing connections between AudioNodes.

• An AudioNode interface, which represents audio sources, audio outputs, and intermediate processing modules. AudioNodes can be dynamically connected together in a modular fashion. AudioNodes exist in the context of an AudioContext.

• An AnalyserNode interface, an AudioNode for use with music visualizers, or other visualization applications.

• An AudioBuffer interface, for working with memory-resident audio assets. These can represent one-shot sounds, or longer audio clips.

• An AudioBufferSourceNode interface, an AudioNode which generates audio from an AudioBuffer.

• An AudioDestinationNode interface, an AudioNode subclass representing the final destination for all rendered audio.

• An AudioParam interface, for controlling an individual aspect of an AudioNode’s functioning, such as volume.

• An AudioListener interface, which works with a PannerNode for spatialization.

• An AudioWorklet interface representing a factory for creating custom nodes that can process audio directly using scripts.

• An AudioWorkletGlobalScope interface, the context in which AudioWorkletProcessor processing scripts run.

• An AudioWorkletNode interface, an AudioNode representing a node processed in an AudioWorkletProcessor.

• An AudioWorkletProcessor interface, representing a single node instance inside an audio worker.

• A BiquadFilterNode interface, an AudioNode for common low-order filters such as:

  • Low Pass

  • High Pass

  • Band Pass

  • Low Shelf

  • High Shelf

  • Peaking

  • Notch

  • Allpass

• A ChannelMergerNode interface, an AudioNode for combining channels from multiple audio streams into a single audio stream.

• A ChannelSplitterNode interface, an AudioNode for accessing the individual channels of an audio stream in the routing graph.

• A ConstantSourceNode interface, an AudioNode for generating a nominally constant output value with an AudioParam to allow automation of the value.

• A ConvolverNode interface, an AudioNode for applying a real-time linear effect (such as the sound of a concert hall).

• A DelayNode interface, an AudioNode which applies a dynamically adjustable variable delay.

• A DynamicsCompressorNode interface, an AudioNode for dynamics compression.

• A GainNode interface, an AudioNode for explicit gain control.

• An IIRFilterNode interface, an AudioNode for a general IIR filter.

• A MediaElementAudioSourceNode interface, an AudioNode which is the audio source from an audio, video, or other media element.

• A MediaStreamAudioSourceNode interface, an AudioNode which is the audio source from a MediaStream such as live audio input, or from a remote peer.

• A MediaStreamTrackAudioSourceNode interface, an AudioNode which is the audio source from a MediaStreamTrack.

• A MediaStreamAudioDestinationNode interface, an AudioNode which is the audio destination to a MediaStream sent to a remote peer.

• A PannerNode interface, an AudioNode for spatializing / positioning audio in 3D space.

• A PeriodicWave interface for specifying custom periodic waveforms for use by the OscillatorNode.

• An OscillatorNode interface, an AudioNode for generating a periodic waveform.

• A StereoPannerNode interface, an AudioNode for equal-power positioning of audio input in a stereo stream.

• A WaveShaperNode interface, an AudioNode which applies a non-linear waveshaping effect for distortion and other more subtle warming effects.

There are also several features that have been deprecated from the Web Audio API but not yet removed, pending implementation experience of their replacements:

• A ScriptProcessorNode interface, an AudioNode for generating or processing audio directly using scripts.

• An AudioProcessingEvent interface, which is an event type used with ScriptProcessorNode objects.

This interface represents a set of AudioNode objects and their connections. It allows for arbitrary routing of signals to an AudioDestinationNode. Nodes are created from the context and are then connected together.

BaseAudioContext is not instantiated directly, but is instead extended by the concrete interfaces AudioContext (for real-time rendering) and OfflineAudioContext (for offline rendering).

BaseAudioContext are created with an internal slot [[pending promises]] that is an initially empty ordered list of promises.

Each BaseAudioContext has a unique media element event task source. Additionally, a BaseAudioContext has several private slots [[rendering thread state]] and [[control thread state]] that take values from AudioContextState, and that are both initially set to "suspended" , [[state before interruption]] that also take values from AudioContextState and is initially set to null and a private slot [[render quantum size]] that is an unsigned integer.

enum AudioContextState {
    "suspended",
    "running",
    "closed",
    "interrupted"
};

enum AudioContextRenderSizeCategory {
    "default",
    "hardware"
};

Note: This exposes information about the host and can be used for fingerprinting.

callback DecodeErrorCallback = undefined (DOMException error);

callback DecodeSuccessCallback = undefined (AudioBuffer decodedData);

[Exposed=Window]
interface BaseAudioContext : EventTarget {
    readonly attribute AudioDestinationNode destination;
    readonly attribute float sampleRate;
    readonly attribute double currentTime;
    readonly attribute AudioListener listener;
    readonly attribute AudioContextState state;
    readonly attribute unsigned long renderQuantumSize;
    [SameObject, SecureContext]
    readonly attribute AudioWorklet audioWorklet;
    attribute EventHandler onstatechange;

    AnalyserNode createAnalyser ();
    BiquadFilterNode createBiquadFilter ();
    AudioBuffer createBuffer (unsigned long numberOfChannels,
                                unsigned long length,
                                float sampleRate);
    AudioBufferSourceNode createBufferSource ();
    ChannelMergerNode createChannelMerger (optional unsigned long numberOfInputs = 6);
    ChannelSplitterNode createChannelSplitter (
        optional unsigned long numberOfOutputs = 6);
    ConstantSourceNode createConstantSource ();
    ConvolverNode createConvolver ();
    DelayNode createDelay (optional double maxDelayTime = 1.0);
    DynamicsCompressorNode createDynamicsCompressor ();
    GainNode createGain ();
    IIRFilterNode createIIRFilter (sequence<double> feedforward,
                                    sequence<double> feedback);
    OscillatorNode createOscillator ();
    PannerNode createPanner ();
    PeriodicWave createPeriodicWave (sequence<float> real,
                                        sequence<float> imag,
                                        optional PeriodicWaveConstraints constraints = {});
    ScriptProcessorNode createScriptProcessor(
        optional unsigned long bufferSize = 0,
        optional unsigned long numberOfInputChannels = 2,
        optional unsigned long numberOfOutputChannels = 2);
    StereoPannerNode createStereoPanner ();
    WaveShaperNode createWaveShaper ();

    Promise<AudioBuffer> decodeAudioData (
        ArrayBuffer audioData,
        optional DecodeSuccessCallback? successCallback,
        optional DecodeErrorCallback? errorCallback);
};

audioWorklet, of type AudioWorklet, readonly

Allows access to the Worklet object that can import a script containing AudioWorkletProcessor class definitions via the algorithms defined by [HTML] and AudioWorklet.

currentTime, of type double, readonly

This is the time in seconds of the sample frame immediately following the last sample-frame in the block of audio most recently processed by the context’s rendering graph. If the context’s rendering graph has not yet processed a block of audio, then currentTime has a value of zero.

In the time coordinate system of currentTime, the value of zero corresponds to the first sample-frame in the first block processed by the graph. Elapsed time in this system corresponds to elapsed time in the audio stream generated by the BaseAudioContext, which may not be synchronized with other clocks in the system. (For an OfflineAudioContext, since the stream is not being actively played by any device, there is not even an approximation to real time.)

All scheduled times in the Web Audio API are relative to the value of currentTime.

When the BaseAudioContext is in the "running" state, the value of this attribute is monotonically increasing and is updated by the rendering thread in uniform increments, corresponding to one render quantum. Thus, for a running context, currentTime increases steadily as the system processes audio blocks, and always represents the time of the start of the next audio block to be processed. It is also the earliest possible time when any change scheduled in the current state might take effect.

currentTime MUST be read atomically on the control thread before being returned.

destination, of type AudioDestinationNode, readonly

An AudioDestinationNode with a single input representing the final destination for all audio. Usually this will represent the actual audio hardware. All AudioNodes actively rendering audio will directly or indirectly connect to destination.

listener, of type AudioListener, readonly

An AudioListener which is used for 3D spatialization.

onstatechange, of type EventHandler

A property used to set an event handler for an event that is dispatched to BaseAudioContext when the state of the AudioContext has changed (i.e. when the corresponding promise would have resolved). The event type of this event handler is statechange. An event that uses the Event interface will be dispatched to the event handler, which can query the AudioContext’s state directly. A newly-created AudioContext will always begin in the suspended state, and a state change event will be fired whenever the state changes to a different state. This event is fired before the complete event is fired.

sampleRate, of type float, readonly

The sample rate (in sample-frames per second) at which the BaseAudioContext handles audio. It is assumed that all AudioNodes in the context run at this rate. In making this assumption, sample-rate converters or "varispeed" processors are not supported in real-time processing. The Nyquist frequency is half this sample-rate value.

state, of type AudioContextState, readonly

Describes the current state of the BaseAudioContext. Getting this attribute returns the contents of the [[control thread state]] slot.

renderQuantumSize, of type unsigned long, readonly

Getting this attribute returns the value of [[render quantum size]] slot.

createAnalyser()

Factory method for an AnalyserNode.

No parameters.

createBiquadFilter()

Factory method for a BiquadFilterNode representing a second order filter which can be configured as one of several common filter types.

No parameters.

createBuffer(numberOfChannels, length, sampleRate)

Creates an AudioBuffer of the given size. The audio data in the buffer will be zero-initialized (silent). A NotSupportedError exception MUST be thrown if any of the arguments is negative, zero, or outside its nominal range.

Arguments for the BaseAudioContext.createBuffer() method. Parameter Type Nullable Optional Description numberOfChannels unsigned long ✘ ✘ Determines how many channels the buffer will have. An implementation MUST support at least 32 channels. length unsigned long ✘ ✘ Determines the size of the buffer in sample-frames. This MUST be at least 1. sampleRate float ✘ ✘ Describes the sample-rate of the linear PCM audio data in the buffer in sample-frames per second. An implementation MUST support sample rates in at least the range 8000 to 96000.

createBufferSource()

Factory method for a AudioBufferSourceNode.

No parameters.

createChannelMerger(numberOfInputs)

Factory method for a ChannelMergerNode representing a channel merger. An IndexSizeError exception MUST be thrown if numberOfInputs is less than 1 or is greater than the number of supported channels.

createChannelSplitter(numberOfOutputs)

Factory method for a ChannelSplitterNode representing a channel splitter. An IndexSizeError exception MUST be thrown if numberOfOutputs is less than 1 or is greater than the number of supported channels.

createConstantSource()

Factory method for a ConstantSourceNode.

No parameters.

createConvolver()

Factory method for a ConvolverNode.

No parameters.

createDelay(maxDelayTime)

Factory method for a DelayNode. The initial default delay time will be 0 seconds.

Arguments for the BaseAudioContext.createDelay(maxDelayTime) method. Parameter Type Nullable Optional Description maxDelayTime double ✘ ✔ Specifies the maximum delay time in seconds allowed for the delay line. If specified, this value MUST be greater than zero and less than three minutes or a NotSupportedError exception MUST be thrown. If not specified, then 1 will be used.

createDynamicsCompressor()

Factory method for a DynamicsCompressorNode.

No parameters.

createGain()

Factory method for GainNode.

No parameters.

createIIRFilter(feedforward, feedback)

Arguments for the BaseAudioContext.createIIRFilter() method. Parameter Type Nullable Optional Description feedforward sequence<double> ✘ ✘ An array of the feedforward (numerator) coefficients for the transfer function of the IIR filter. The maximum length of this array is 20. If all of the values are zero, an InvalidStateError MUST be thrown. A NotSupportedError MUST be thrown if the array length is 0 or greater than 20. feedback sequence<double> ✘ ✘ An array of the feedback (denominator) coefficients for the transfer function of the IIR filter. The maximum length of this array is 20. If the first element of the array is 0, an InvalidStateError MUST be thrown. A NotSupportedError MUST be thrown if the array length is 0 or greater than 20.

createOscillator()

Factory method for an OscillatorNode.

No parameters.

createPanner()

Factory method for a PannerNode.

No parameters.

createPeriodicWave(real, imag, constraints)

Factory method to create a PeriodicWave.

When calling this method, execute these steps:

1. If real and imag are not of the same length, an IndexSizeError MUST be thrown.

2. Let o be a new object of type PeriodicWaveOptions.

3. Respectively set the real and imag parameters passed to this factory method to the attributes of the same name on o.

4. Set the disableNormalization attribute on o to the value of the disableNormalization attribute of the constraints attribute passed to the factory method.

5. Construct a new PeriodicWave p, passing the BaseAudioContext this factory method has been called on as a first argument, and o.

6. Return p.

Arguments for the BaseAudioContext.createPeriodicWave() method. Parameter Type Nullable Optional Description real sequence<float> ✘ ✘ A sequence of cosine parameters. See its real constructor argument for a more detailed description. imag sequence<float> ✘ ✘ A sequence of sine parameters. See its imag constructor argument for a more detailed description. constraints PeriodicWaveConstraints ✘ ✔ If not given, the waveform is normalized. Otherwise, the waveform is normalized according the value given by constraints.

createScriptProcessor(bufferSize, numberOfInputChannels, numberOfOutputChannels)

Factory method for a ScriptProcessorNode. This method is DEPRECATED, as it is intended to be replaced by AudioWorkletNode. Creates a ScriptProcessorNode for direct audio processing using scripts. An IndexSizeError exception MUST be thrown if bufferSize or numberOfInputChannels or numberOfOutputChannels are outside the valid range.

It is invalid for both numberOfInputChannels and numberOfOutputChannels to be zero. In this case an IndexSizeError MUST be thrown.

Arguments for the BaseAudioContext.createScriptProcessor(bufferSize, numberOfInputChannels, numberOfOutputChannels) method. Parameter Type Nullable Optional Description bufferSize unsigned long ✘ ✔ The bufferSize parameter determines the buffer size in units of sample-frames. If it’s not passed in, or if the value is 0, then the implementation will choose the best buffer size for the given environment, which will be constant power of 2 throughout the lifetime of the node. Otherwise if the author explicitly specifies the bufferSize, it MUST be one of the following values: 256, 512, 1024, 2048, 4096, 8192, 16384. This value controls how frequently the audioprocess event is dispatched and how many sample-frames need to be processed each call. Lower values for bufferSize will result in a lower (better) latency. Higher values will be necessary to avoid audio breakup and glitches. It is recommended for authors to not specify this buffer size and allow the implementation to pick a good buffer size to balance between latency and audio quality. If the value of this parameter is not one of the allowed power-of-2 values listed above, an IndexSizeError MUST be thrown. numberOfInputChannels unsigned long ✘ ✔ This parameter determines the number of channels for this node’s input. The default value is 2. Values of up to 32 must be supported. A NotSupportedError must be thrown if the number of channels is not supported. numberOfOutputChannels unsigned long ✘ ✔ This parameter determines the number of channels for this node’s output. The default value is 2. Values of up to 32 must be supported. A NotSupportedError must be thrown if the number of channels is not supported.

createStereoPanner()

Factory method for a StereoPannerNode.

No parameters.

createWaveShaper()

Factory method for a WaveShaperNode representing a non-linear distortion.

No parameters.

decodeAudioData(audioData, successCallback, errorCallback)

Asynchronously decodes the audio file data contained in the ArrayBuffer. The ArrayBuffer can, for example, be loaded from an XMLHttpRequest’s response attribute after setting the responseType to "arraybuffer". Audio file data can be in any of the formats supported by the audio element. The buffer passed to decodeAudioData() has its content-type determined by sniffing, as described in [mimesniff].

Although the primary method of interfacing with this function is via its promise return value, the callback parameters are provided for legacy reasons.

Encourage implementation to warn authors in case of a corrupted file. It isn’t possible to throw because this would be a breaking change.

Note: If the compressed audio data byte-stream is corrupted but the decoding can otherwise proceed, implementations are encouraged to warn authors for example via the developer tools.

When queuing a decoding operation to be performed on another thread, the following steps MUST happen on a thread that is not the

control thread

nor the

rendering thread

, called the

decoding thread

.

Note: Multiple decoding threads can run in parallel to service multiple calls to decodeAudioData.

1. Let can decode be a boolean flag, initially set to true.

2. Attempt to determine the MIME type of audioData, using MIME Sniffing § 6.2 Matching an audio or video type pattern. If the audio or video type pattern matching algorithm returns undefined, set can decode to false.

3. If can decode is true, attempt to decode the encoded audioData into linear PCM. In case of failure, set can decode to false.

   If the media byte-stream contains multiple audio tracks, only decode the first track to linear pcm.

   Note: Authors who need more control over the decoding process can use [WEBCODECS].

4. If can decode is false, queue a media element task to execute the following steps:

   1. Let error be a DOMException whose name is EncodingError.

      1. Reject promise with error, and remove it from [[pending promises]].

   2. If errorCallback is not missing, invoke errorCallback with error.

5. Otherwise:

   1. Take the result, representing the decoded linear PCM audio data, and resample it to the sample-rate of the BaseAudioContext if it is different from the sample-rate of audioData.

   2. queue a media element task to execute the following steps:

      1. Let buffer be an AudioBuffer containing the final result (after possibly performing sample-rate conversion).

      2. Resolve promise with buffer.

      3. If successCallback is not missing, invoke successCallback with buffer.

Arguments for the BaseAudioContext.decodeAudioData() method. Parameter Type Nullable Optional Description audioData ArrayBuffer ✘ ✘ An ArrayBuffer containing compressed audio data. successCallback DecodeSuccessCallback? ✔ ✔ A callback function which will be invoked when the decoding is finished. The single argument to this callback is an AudioBuffer representing the decoded PCM audio data. errorCallback DecodeErrorCallback? ✔ ✔ A callback function which will be invoked if there is an error decoding the audio file.

decodedData, of type AudioBuffer

The AudioBuffer containing the decoded audio data.

error, of type DOMException

The error that occurred while decoding.

Once created, an AudioContext will continue to play sound until it has no more sound to play, or the page goes away.

The Web Audio API takes a fire-and-forget approach to audio source scheduling. That is, source nodes are created for each note during the lifetime of the AudioContext, and never explicitly removed from the graph. This is incompatible with a serialization API, since there is no stable set of nodes that could be serialized.

Moreover, having an introspection API would allow content script to be able to observe garbage collections.

The subclasses AudioContext and OfflineAudioContext should be considered expensive objects. Creating these objects may involve creating a high-priority thread, or using a low-latency system audio stream, both having an impact on energy consumption. It is usually not necessary to create more than one AudioContext in a document.

Constructing or resuming a BaseAudioContext subclass involves acquiring system resources for that context. For AudioContext, this also requires creation of a system audio stream. These operations return when the context begins generating output from its associated audio graph.

Additionally, a user-agent can have an implementation-defined maximum number of AudioContexts, after which any attempt to create a new AudioContext will fail, throwing NotSupportedError.

suspend and close allow authors to release system resources, including threads, processes and audio streams. Suspending a BaseAudioContext permits implementations to release some of its resources, and allows it to continue to operate later by invoking resume. Closing an AudioContext permits implementations to release all of its resources, after which it cannot be used or resumed again.

Note: For example, this can involve waiting for the audio callbacks to fire regularly, or to wait for the hardware to be ready for processing.

This interface represents an audio graph whose AudioDestinationNode is routed to a real-time output device that produces a signal directed at the user. In most use cases, only a single AudioContext is used per document.

enum AudioContextLatencyCategory {
        "balanced",
        "interactive",
        "playback"
};

enum AudioSinkType {
    "none"
};

[Exposed=Window]
interface AudioContext : BaseAudioContext {
    constructor (optional AudioContextOptions contextOptions = {});
    readonly attribute double baseLatency;
    readonly attribute double outputLatency;
    [SecureContext] readonly attribute (DOMString or AudioSinkInfo) sinkId;
    attribute EventHandler onsinkchange;
    attribute EventHandler onerror;
    AudioTimestamp getOutputTimestamp ();
    Promise<undefined> resume ();
    Promise<undefined> suspend ();
    Promise<undefined> close ();
    [SecureContext] Promise<undefined> setSinkId ((DOMString or AudioSinkOptions) sinkId);
    MediaElementAudioSourceNode createMediaElementSource (HTMLMediaElement mediaElement);
    MediaStreamAudioSourceNode createMediaStreamSource (MediaStream mediaStream);
    MediaStreamTrackAudioSourceNode createMediaStreamTrackSource (
        MediaStreamTrack mediaStreamTrack);
    MediaStreamAudioDestinationNode createMediaStreamDestination ();
};

An AudioContext is said to be allowed to start if the user agent allows the context state to transition from "suspended" to "running". A user agent may disallow this initial transition, and to allow it only when the AudioContext’s relevant global object has sticky activation.

AudioContext has following internal slots:

[[suspended by user]]

A boolean flag representing whether the context is suspended by user code. The initial value is false.

[[sink ID]]

A DOMString or an AudioSinkInfo representing the identifier or the information of the current audio output device respectively. The initial value is "", which means the default audio output device.

[[sink ID at construction]]

A DOMString or an AudioSinkInfo representing the identifier or the information of the audio output device requested at construction, respectively. The initial value is "", which means the default audio output device.

[[pending resume promises]]

An ordered list to store pending Promises created by resume(). It is initially empty.

AudioContext(contextOptions)

If the current settings object’s relevant global object’s associated Document is NOT fully active, throw an "InvalidStateError" and abort these steps.

When creating an AudioContext, execute these steps:

1. Let context be a new AudioContext object.

2. Set a [[control thread state]] to suspended on context.

3. Set a [[rendering thread state]] to suspended on context.

4. Set [[state before interruption]] to null on context.

5. Let messageChannel be a new MessageChannel.

6. Let controlSidePort be the value of messageChannel’s port1 attribute.

7. Let renderingSidePort be the value of messageChannel’s port2 attribute.

8. Let serializedRenderingSidePort be the result of StructuredSerializeWithTransfer(renderingSidePort, « renderingSidePort »).

9. Set this audioWorklet’s port to controlSidePort.

10. Queue a control message to set the MessagePort on the AudioContextGlobalScope, with serializedRenderingSidePort.

11. If contextOptions is given, perform the following substeps:

    1. If sinkId is specified, let sinkId be the value of contextOptions.sinkId and run the following substeps:

       1. If both sinkId and [[sink ID]] are a type of DOMString, and they are equal to each other, abort these substeps.

       2. If sinkId is a type of AudioSinkOptions and [[sink ID]] is a type of AudioSinkInfo, and type in sinkId and type in [[sink ID]] are equal, abort these substeps.

       3. If sinkId is a type of DOMString, set [[sink ID at construction]] to sinkId and abort these substeps.

       4. If sinkId is a type of AudioSinkOptions, set [[sink ID at construction]] to a new instance of AudioSinkInfo created with the value of type of sinkId.

    2. Set the internal latency of context according to contextOptions.latencyHint, as described in latencyHint.

    3. If contextOptions.sampleRate is specified, set the sampleRate of context to this value. Otherwise, follow these substeps:

       1. If sinkId is the empty string or a type of AudioSinkOptions, use the sample rate of the default output device. Abort these substeps.

       2. If sinkId is a DOMString, use the sample rate of the output device identified by sinkId. Abort these substeps.

       If contextOptions.sampleRate differs from the sample rate of the output device, the user agent MUST resample the audio output to match the sample rate of the output device.

       Note: If resampling is required, the latency of context may be affected, possibly by a large amount.

12. If context is allowed to start, send a control message to start processing.

13. Return context.

NOTE: In cases where an AudioContext is constructed with no arguments and resource acquisition fails, the User-Agent will attempt to silently render the audio graph using a mechanism that emulates an audio output device.

baseLatency, of type double, readonly

This represents the number of seconds of processing latency incurred by the AudioContext passing the audio from the AudioDestinationNode to the audio subsystem. It does not include any additional latency that might be caused by any other processing between the output of the AudioDestinationNode and the audio hardware and specifically does not include any latency incurred the audio graph itself.

For example, if the audio context is running at 44.1 kHz with default render quantum size, and the AudioDestinationNode implements double buffering internally and can process and output audio each render quantum, then the processing latency is \((2\cdot128)/44100 = 5.805 \mathrm{ ms}\), approximately.

outputLatency, of type double, readonly

The estimation in seconds of audio output latency, i.e., the interval between the time the UA requests the host system to play a buffer and the time at which the first sample in the buffer is actually processed by the audio output device. For devices such as speakers or headphones that produce an acoustic signal, this latter time refers to the time when a sample’s sound is produced.

An outputLatency attribute value depends on the platform and the connected audio output device hardware. The outputLatency attribute value may change while the context is running or the associated audio output device changes. It is useful to query this value frequently when accurate synchronization is required.

sinkId, of type (DOMString or AudioSinkInfo), readonly

Returns the value of [[sink ID]] internal slot. This attribute is cached upon update, and it returns the same object after caching.

onsinkchange, of type EventHandler

An event handler for setSinkId(). The event type of this event handler is sinkchange. This event will be dispatched when changing the output device is completed.

NOTE: This is not dispatched for the initial device selection in the construction of AudioContext. The statechange event is available to check the readiness of the initial output device.

onerror, of type EventHandler

An event handler for the Event dispatched from an AudioContext. The event type of this handler is error and the user agent can dispatch this event in the following cases:

• When initializing and activating a selected audio device encounters failures.

• When the audio output device associated with an AudioContext is disconnected while the context is running.

• When the operating system reports an audio device malfunction.

close()

Closes the AudioContext, releasing the system resources being used. This will not automatically release all AudioContext-created objects, but will suspend the progression of the AudioContext’s currentTime, and stop processing audio data.

When an AudioContext is closed, any MediaStreams and HTMLMediaElements that were connected to an AudioContext will have their output ignored. That is, these will no longer cause any output to speakers or other output devices. For more flexibility in behavior, consider using HTMLMediaElement.captureStream().

Note: When an AudioContext has been closed, implementation can choose to aggressively release more resources than when suspending.

No parameters.

createMediaElementSource(mediaElement)

Creates a MediaElementAudioSourceNode given an HTMLMediaElement. As a consequence of calling this method, audio playback from the HTMLMediaElement will be re-routed into the processing graph of the AudioContext.

createMediaStreamDestination()

Creates a MediaStreamAudioDestinationNode

No parameters.

createMediaStreamSource(mediaStream)

Creates a MediaStreamAudioSourceNode.

createMediaStreamTrackSource(mediaStreamTrack)

Creates a MediaStreamTrackAudioSourceNode.

getOutputTimestamp()

Returns a new AudioTimestamp instance containing two related audio stream position values for the context: the contextTime member contains the time of the sample frame which is currently being rendered by the audio output device (i.e., output audio stream position), in the same units and origin as context’s currentTime; the performanceTime member contains the time estimating the moment when the sample frame corresponding to the stored contextTime value was rendered by the audio output device, in the same units and origin as performance.now() (described in [hr-time-3]).

If the context’s rendering graph has not yet processed a block of audio, then getOutputTimestamp call returns an AudioTimestamp instance with both members containing zero.

After the context’s rendering graph has started processing of blocks of audio, its currentTime attribute value always exceeds the contextTime value obtained from getOutputTimestamp method call.

The value returned from

getOutputTimestamp

method can be used to get performance time estimation for the slightly later context’s time value:

function outputPerformanceTime(contextTime) {
    const timestamp = context.getOutputTimestamp();
    const elapsedTime = contextTime - timestamp.contextTime;
    return timestamp.performanceTime + elapsedTime * 1000;
}

In the above example the accuracy of the estimation depends on how close the argument value is to the current output audio stream position: the closer the given contextTime is to timestamp.contextTime, the better the accuracy of the obtained estimation.

Note: The difference between the values of the context’s currentTime and the contextTime obtained from getOutputTimestamp method call cannot be considered as a reliable output latency estimation because currentTime may be incremented at non-uniform time intervals, so outputLatency attribute should be used instead.

No parameters.

resume()

Resumes the progression of the AudioContext’s currentTime when it has been suspended.

Running a

control message

to resume an

AudioContext

means running these steps on the

rendering thread

:

1. Let promise be the promise passed into this algorithm.

2. Attempt to acquire system resources.

3. Set the [[rendering thread state]] on the AudioContext to running.

4. Start rendering the audio graph.

5. In case of failure, queue a media element task to execute the following steps:

   1. Reject all promises from [[pending resume promises]] in order, then clear [[pending resume promises]].

   2. Additionally, remove those promises from [[pending promises]].

6. queue a media element task to execute the following steps:

   1. Resolve all promises from [[pending resume promises]] in order.

   2. Clear [[pending resume promises]]. Additionally, remove those promises from [[pending promises]].

   3. Resolve promise.

   4. If the state attribute of the AudioContext is not already "running":

      1. Set the state attribute of the AudioContext to "running".

      2. Queue a media element task to fire an event named statechange at the AudioContext.

No parameters.

suspend()

Suspends the progression of AudioContext’s currentTime, allows any current context processing blocks that are already processed to be played to the destination, and then allows the system to release its claim on audio hardware. This is generally useful when the application knows it will not need the AudioContext for some time, and wishes to temporarily release system resource associated with the AudioContext. The promise resolves when the frame buffer is empty (has been handed off to the hardware), or immediately (with no other effect) if the context is already suspended. The promise is rejected if the context has been closed.

While an AudioContext is suspended, MediaStreams will have their output ignored; that is, data will be lost by the real time nature of media streams. HTMLMediaElements will similarly have their output ignored until the system is resumed. AudioWorkletNodes and ScriptProcessorNodes will cease to have their processing handlers invoked while suspended, but will resume when the context is resumed. For the purpose of AnalyserNode window functions, the data is considered as a continuous stream - i.e. the resume()/suspend() does not cause silence to appear in the AnalyserNode’s stream of data. In particular, calling AnalyserNode functions repeatedly when a AudioContext is suspended MUST return the same data.

No parameters.

setSinkId((DOMString or AudioSinkOptions) sinkId)

Sets the identifier of an output device. When this method is invoked, the user agent MUST run the following steps:

1. Let sinkId be the method’s first argument.

2. If sinkId is equal to [[sink ID]], return a promise, resolve it immediately and abort these steps.

3. Let validationResult be the return value of sink identifier validation of sinkId.

4. If validationResult is false, return a promise rejected with a new DOMException whose name is "NotAllowedError". Abort these steps.

5. Let p be a new promise.

6. Send a control message with p and sinkId to start processing.

7. Return p.

This algorithm is used to validate the information provided to modify sinkId:

1. Let document be the current settings object’s associated Document.

2. Let sinkIdArg be the value passed in to this algorithm.

3. If document is not allowed to use the feature identified by "speaker-selection", return false.

4. If sinkIdArg is a type of DOMString but it is not equal to the empty string or it does not match any audio output device identified by the result that would be provided by enumerateDevices(), return false.

5. Return true.

The AudioContextOptions dictionary is used to specify user-specified options for an AudioContext.

dictionary AudioContextOptions {
    (AudioContextLatencyCategory or double) latencyHint = "interactive";
    float sampleRate;
    (DOMString or AudioSinkOptions) sinkId;
    (AudioContextRenderSizeCategory or unsigned long) renderSizeHint = "default";
};

latencyHint, of type (AudioContextLatencyCategory or double), defaulting to "interactive"

Identify the type of playback, which affects tradeoffs between audio output latency and power consumption.

The preferred value of the latencyHint is a value from AudioContextLatencyCategory. However, a double can also be specified for the number of seconds of latency for finer control to balance latency and power consumption. It is at the browser’s discretion to interpret the number appropriately. The actual latency used is given by AudioContext’s baseLatency attribute.

sampleRate, of type float

Set the sampleRate to this value for the AudioContext that will be created. The supported values are the same as the sample rates for an AudioBuffer. A NotSupportedError exception MUST be thrown if the specified sample rate is not supported.

If sampleRate is not specified, the preferred sample rate of the output device for this AudioContext is used.

sinkId, of type (DOMString or AudioSinkOptions)

The identifier or associated information of the audio output device. See sinkId for more details.

renderSizeHint, of type (AudioContextRenderSizeCategory or unsigned long), defaulting to "default"

This allows users to ask for a particular render quantum size when an integer is passed, to use the default of 128 frames if nothing or "default" is passed, or to ask the User-Agent to pick a good render quantum size if "hardware" is specified.

It is a hint that might not be honored.

The AudioSinkOptions dictionary is used to specify options for sinkId.

dictionary AudioSinkOptions {
    required AudioSinkType type;
};

type, of type AudioSinkType

A value of AudioSinkType to specify the type of the device.

The AudioSinkInfo interface is used to get information on the current audio output device via sinkId.

[Exposed=Window]
interface AudioSinkInfo {
    readonly attribute AudioSinkType type;
};

type, of type AudioSinkType, readonly

A value of AudioSinkType that represents the type of the device.

dictionary AudioTimestamp {
    double contextTime;
    DOMHighResTimeStamp performanceTime;
};

contextTime, of type double

Represents a point in the time coordinate system of BaseAudioContext’s currentTime.

performanceTime, of type DOMHighResTimeStamp

Represents a point in the time coordinate system of a Performance interface implementation (described in [hr-time-3]).

OfflineAudioContext is a particular type of BaseAudioContext for rendering/mixing-down (potentially) faster than real-time. It does not render to the audio hardware, but instead renders as quickly as possible, fulfilling the returned promise with the rendered result as an AudioBuffer.

[Exposed=Window]
interface OfflineAudioContext : BaseAudioContext {
    constructor(OfflineAudioContextOptions contextOptions);
    constructor(unsigned long numberOfChannels, unsigned long length, float sampleRate);
    Promise<AudioBuffer> startRendering();
    Promise<undefined> resume();
    Promise<undefined> suspend(double suspendTime);
    readonly attribute unsigned long length;
    attribute EventHandler oncomplete;
};

OfflineAudioContext(contextOptions)

OfflineAudioContext(numberOfChannels, length, sampleRate)

The OfflineAudioContext can be constructed with the same arguments as AudioContext.createBuffer. A NotSupportedError exception MUST be thrown if any of the arguments is negative, zero, or outside its nominal range.

The OfflineAudioContext is constructed as if

new OfflineAudioContext({
        numberOfChannels: numberOfChannels,
        length: length,
        sampleRate: sampleRate
})

were called instead.

length, of type unsigned long, readonly

The size of the buffer in sample-frames. This is the same as the value of the length parameter for the constructor.

oncomplete, of type EventHandler

The event type of this event handler is complete. The event dispatched to the event handler will use the OfflineAudioCompletionEvent interface. It is the last event fired on an OfflineAudioContext.

startRendering()

Given the current connections and scheduled changes, starts rendering audio.

Although the primary method of getting the rendered audio data is via its promise return value, the instance will also fire an event named complete for legacy reasons.

No parameters.

resume()

Resumes the progression of the OfflineAudioContext’s currentTime when it has been suspended.

No parameters.

suspend(suspendTime)

Schedules a suspension of the time progression in the audio context at the specified time and returns a promise. This is generally useful when manipulating the audio graph synchronously on OfflineAudioContext.

Note that the maximum precision of suspension is the size of the render quantum and the specified suspension time will be rounded up to the nearest render quantum boundary. For this reason, it is not allowed to schedule multiple suspends at the same quantized frame. Also, scheduling should be done while the context is not running to ensure precise suspension.

Arguments for the OfflineAudioContext.suspend() method. Parameter Type Nullable Optional Description suspendTime double ✘ ✘ Schedules a suspension of the rendering at the specified time, which is quantized and rounded up to the render quantum size. If the quantized frame number

1. is negative or
2. is less than or equal to the current time or
3. is greater than or equal to the total render duration or
4. is scheduled by another suspend for the same time,

then the promise is rejected with InvalidStateError.

This specifies the options to use in constructing an OfflineAudioContext.

dictionary OfflineAudioContextOptions {
    unsigned long numberOfChannels = 1;
    required unsigned long length;
    required float sampleRate;
    (AudioContextRenderSizeCategory or unsigned long) renderSizeHint = "default";
};

length, of type unsigned long

The length of the rendered AudioBuffer in sample-frames.

numberOfChannels, of type unsigned long, defaulting to 1

The number of channels for this OfflineAudioContext.

sampleRate, of type float

The sample rate for this OfflineAudioContext.

renderSizeHint, of type (AudioContextRenderSizeCategory or unsigned long), defaulting to "default"

A hint for the render quantum size of this OfflineAudioContext.

This is an Event object which is dispatched to OfflineAudioContext for legacy reasons.

[Exposed=Window]
interface OfflineAudioCompletionEvent : Event {
    constructor (DOMString type, OfflineAudioCompletionEventInit eventInitDict);
    readonly attribute AudioBuffer renderedBuffer;
};

renderedBuffer, of type AudioBuffer, readonly

An AudioBuffer containing the rendered audio data.

dictionary OfflineAudioCompletionEventInit : EventInit {
    required AudioBuffer renderedBuffer;
};

renderedBuffer, of type AudioBuffer

Value to be assigned to the renderedBuffer attribute of the event.

This interface represents a memory-resident audio asset. It can contain one or more channels with each channel appearing to be 32-bit floating-point linear PCM values with a nominal range of \([-1,1]\) but the values are not limited to this range. Typically, it would be expected that the length of the PCM data would be fairly short (usually somewhat less than a minute). For longer sounds, such as music soundtracks, streaming should be used with the audio element and MediaElementAudioSourceNode.

An AudioBuffer may be used by one or more AudioContexts, and can be shared between an OfflineAudioContext and an AudioContext.

AudioBuffer has four internal slots:

[[number of channels]]

The number of audio channels for this AudioBuffer, which is an unsigned long.

[[length]]

The length of each channel of this AudioBuffer, which is an unsigned long.

[[sample rate]]

The sample-rate, in Hz, of this AudioBuffer, a float.

[[internal data]]

A data block holding the audio sample data.

[Exposed=Window]
interface AudioBuffer {
    constructor (AudioBufferOptions options);
    readonly attribute float sampleRate;
    readonly attribute unsigned long length;
    readonly attribute double duration;
    readonly attribute unsigned long numberOfChannels;
    Float32Array getChannelData (unsigned long channel);
    undefined copyFromChannel (Float32Array destination,
                               unsigned long channelNumber,
                               optional unsigned long bufferOffset = 0);
    undefined copyToChannel (Float32Array source,
                             unsigned long channelNumber,
                             optional unsigned long bufferOffset = 0);
};

AudioBuffer(options)

duration, of type double, readonly

Duration of the PCM audio data in seconds.

This is computed from the [[sample rate]] and the [[length]] of the AudioBuffer by performing a division between the [[length]] and the [[sample rate]].

length, of type unsigned long, readonly

Length of the PCM audio data in sample-frames. This MUST return the value of [[length]].

numberOfChannels, of type unsigned long, readonly

The number of discrete audio channels. This MUST return the value of [[number of channels]].

sampleRate, of type float, readonly

The sample-rate for the PCM audio data in samples per second. This MUST return the value of [[sample rate]].

copyFromChannel(destination, channelNumber, bufferOffset)

The copyFromChannel() method copies the samples from the specified channel of the AudioBuffer to the destination array.

Let buffer be the AudioBuffer with \(N_b\) frames, let \(N_f\) be the number of elements in the destination array, and \(k\) be the value of bufferOffset. Then the number of frames copied from buffer to destination is \(\max(0, \min(N_b - k, N_f))\). If this is less than \(N_f\), then the remaining elements of destination are not modified.

copyToChannel(source, channelNumber, bufferOffset)

The copyToChannel() method copies the samples to the specified channel of the AudioBuffer from the source array.

A UnknownError may be thrown if source cannot be copied to the buffer.

Let buffer be the AudioBuffer with \(N_b\) frames, let \(N_f\) be the number of elements in the source array, and \(k\) be the value of bufferOffset. Then the number of frames copied from source to the buffer is \(\max(0, \min(N_b - k, N_f))\). If this is less than \(N_f\), then the remaining elements of buffer are not modified.

getChannelData(channel)

According to the rules described in acquire the content either allow writing into or getting a copy of the bytes stored in [[internal data]] in a new Float32Array

A UnknownError may be thrown if the [[internal data]] or the new Float32Array cannot be created.

Note: The methods copyToChannel() and copyFromChannel() can be used to fill part of an array by passing in a Float32Array that’s a view onto the larger array. When reading data from an AudioBuffer’s channels, and the data can be processed in chunks, copyFromChannel() should be preferred to calling getChannelData() and accessing the resulting array, because it may avoid unnecessary memory allocation and copying.

An internal operation acquire the contents of an AudioBuffer is invoked when the contents of an AudioBuffer are needed by some API implementation. This operation returns immutable channel data to the invoker.

The acquire the contents of an AudioBuffer operation is invoked in the following cases:

• When AudioBufferSourceNode.start is called, it acquires the contents of the node’s buffer. If the operation fails, nothing is played.

• When the buffer of an AudioBufferSourceNode is set and AudioBufferSourceNode.start has been previously called, the setter acquires the content of the AudioBuffer. If the operation fails, nothing is played.

• When a ConvolverNode’s buffer is set to an AudioBuffer it acquires the content of the AudioBuffer.

• When the dispatch of an AudioProcessingEvent completes, it acquires the contents of its outputBuffer.

Note: This means that copyToChannel() cannot be used to change the content of an AudioBuffer currently in use by an AudioNode that has acquired the content of an AudioBuffer since the AudioNode will continue to use the data previously acquired.

This specifies the options to use in constructing an AudioBuffer. The length and sampleRate members are required.

dictionary AudioBufferOptions {
    unsigned long numberOfChannels = 1;
    required unsigned long length;
    required float sampleRate;
};

The allowed values for the members of this dictionary are constrained. See createBuffer().

length, of type unsigned long

The length in sample frames of the buffer. See length for constraints.

numberOfChannels, of type unsigned long, defaulting to 1

The number of channels for the buffer. See numberOfChannels for constraints.

sampleRate, of type float

The sample rate in Hz for the buffer. See sampleRate for constraints.

AudioNodes are the building blocks of an AudioContext. This interface represents audio sources, the audio destination, and intermediate processing modules. These modules can be connected together to form processing graphs for rendering audio to the audio hardware. Each node can have inputs and/or outputs. A source node has no inputs and a single output. Most processing nodes such as filters will have one input and one output. Each type of AudioNode differs in the details of how it processes or synthesizes audio. But, in general, an AudioNode will process its inputs (if it has any), and generate audio for its outputs (if it has any).

Each output has one or more channels. The exact number of channels depends on the details of the specific AudioNode.

An output may connect to one or more AudioNode inputs, thus fan-out is supported. An input initially has no connections, but may be connected from one or more AudioNode outputs, thus fan-in is supported. When the connect() method is called to connect an output of an AudioNode to an input of an AudioNode, we call that a connection to the input.

Each AudioNode input has a specific number of channels at any given time. This number can change depending on the connection(s) made to the input. If the input has no connections then it has one channel which is silent.

For each input, an AudioNode performs a mixing of all connections to that input. Please see § 4 Channel Up-Mixing and Down-Mixing for normative requirements and details.

The processing of inputs and the internal operations of an AudioNode take place continuously with respect to AudioContext time, regardless of whether the node has connected outputs, and regardless of whether these outputs ultimately reach an AudioContext’s AudioDestinationNode.

[Exposed=Window]
interface AudioNode : EventTarget {
    AudioNode connect (AudioNode destinationNode,
                       optional unsigned long output = 0,
                       optional unsigned long input = 0);
    undefined connect (AudioParam destinationParam, optional unsigned long output = 0);
    undefined disconnect ();
    undefined disconnect (unsigned long output);
    undefined disconnect (AudioNode destinationNode);
    undefined disconnect (AudioNode destinationNode, unsigned long output);
    undefined disconnect (AudioNode destinationNode,
                          unsigned long output,
                          unsigned long input);
    undefined disconnect (AudioParam destinationParam);
    undefined disconnect (AudioParam destinationParam, unsigned long output);
    readonly attribute BaseAudioContext context;
    readonly attribute unsigned long numberOfInputs;
    readonly attribute unsigned long numberOfOutputs;
    attribute unsigned long channelCount;
    attribute ChannelCountMode channelCountMode;
    attribute ChannelInterpretation channelInterpretation;
};

AudioNodes can be created in two ways: by using the constructor for this particular interface, or by using the factory method on the BaseAudioContext or AudioContext.

The BaseAudioContext passed as first argument of the constructor of an AudioNodes is called the associated BaseAudioContext of the AudioNode to be created. Similarly, when using the factory method, the associated BaseAudioContext of the AudioNode is the BaseAudioContext this factory method is called on.

To create a new

of a particular type

using its

, called on a

, execute these steps:

1. Let node be a new object of type n.

2. Let option be a dictionary of the type associated to the interface associated to this factory method.

3. For each parameter passed to the factory method, set the dictionary member of the same name on option to the value of this parameter.

4. Call the constructor for n on node with c and option as arguments.

5. Return node

an object

that inherits from

means executing the following steps, given the arguments

and

passed to the constructor of this interface.

1. Set o’s associated BaseAudioContext to context.

2. Set its value for numberOfInputs, numberOfOutputs, channelCount, channelCountMode, channelInterpretation to the default value for this specific interface outlined in the section for each AudioNode.

3. For each member of dict passed in, execute these steps, with k the key of the member, and v its value. If any exceptions is thrown when executing these steps, abort the iteration and propagate the exception to the caller of the algorithm (constructor or factory method).

   1. If k is the name of an AudioParam on this interface, set the value attribute of this AudioParam to v.

   2. Else if k is the name of an attribute on this interface, set the object associated with this attribute to v.

The associated interface for a factory method is the interface of the objects that are returned from this method. The associated option object for an interface is the option object that can be passed to the constructor for this interface.

AudioNodes are EventTargets, as described in [DOM]. This means that it is possible to dispatch events to AudioNodes the same way that other EventTargets accept events.

enum ChannelCountMode {
    "max",
    "clamped-max",
    "explicit"
};

The ChannelCountMode, in conjuction with the node’s channelCount and channelInterpretation values, is used to determine the computedNumberOfChannels that controls how inputs to a node are to be mixed. The computedNumberOfChannels is determined as shown below. See § 4 Channel Up-Mixing and Down-Mixing for more information on how mixing is to be done.

enum ChannelInterpretation {
    "speakers",
    "discrete"
};

An AudioNode can have a tail-time. This means that even when the AudioNode is fed silence, the output can be non-silent.

AudioNodes have a non-zero tail-time if they have internal processing state such that input in the past affects the future output. AudioNodes may continue to produce non-silent output for the calculated tail-time even after the input transitions from non-silent to silent.

AudioNode can be actively processing during a render quantum, if any of the following conditions hold.

• An AudioScheduledSourceNode is actively processing if and only if it is playing for at least part of the current rendering quantum.

• A MediaElementAudioSourceNode is actively processing if and only if its mediaElement is playing for at least part of the current rendering quantum.

• A MediaStreamAudioSourceNode or a MediaStreamTrackAudioSourceNode are actively processing when the associated MediaStreamTrack object has a readyState attribute equal to "live", a muted attribute equal to false and an enabled attribute equal to true.

• A DelayNode in a cycle is actively processing only when the absolute value of any output sample for the current render quantum is greater than or equal to \( 2^{-126} \).

• A ScriptProcessorNode is actively processing when its input or output is connected.

• An AudioWorkletNode is actively processing when its AudioWorkletProcessor’s [[callable process]] returns true and either its active source flag is true or any AudioNode connected to one of its inputs is actively processing.

• All other AudioNodes start actively processing when any AudioNode connected to one of its inputs is actively processing, and stops actively processing when the input that was received from other actively processing AudioNode no longer affects the output.

Note: This takes into account AudioNodes that have a tail-time.

AudioNodes that are not actively processing output a single channel of silence.

channelCount, of type unsigned long

channelCount is the number of channels used when up-mixing and down-mixing connections to any inputs to the node. The default value is 2 except for specific nodes where its value is specially determined. This attribute has no effect for nodes with no inputs. If this value is set to zero or to a value greater than the implementation’s maximum number of channels the implementation MUST throw a NotSupportedError exception.

In addition, some nodes have additional channelCount constraints on the possible values for the channel count:

AudioDestinationNode

The behavior depends on whether the destination node is the destination of an AudioContext or OfflineAudioContext:

AudioContext

The channel count MUST be between 1 and maxChannelCount. An IndexSizeError exception MUST be thrown for any attempt to set the count outside this range.

OfflineAudioContext

The channel count cannot be changed. An InvalidStateError exception MUST be thrown for any attempt to change the value.

AudioWorkletNode

See § 1.32.4.3.2 Configuring Channels with AudioWorkletNodeOptions Configuring Channels with AudioWorkletNodeOptions.

ChannelMergerNode

The channel count cannot be changed, and an InvalidStateError exception MUST be thrown for any attempt to change the value.

ChannelSplitterNode

The channel count cannot be changed, and an InvalidStateError exception MUST be thrown for any attempt to change the value.

ConvolverNode

The channel count cannot be greater than two, and a NotSupportedError exception MUST be thrown for any attempt to change it to a value greater than two.

DynamicsCompressorNode

The channel count cannot be greater than two, and a NotSupportedError exception MUST be thrown for any attempt to change it to a value greater than two.

PannerNode

The channel count cannot be greater than two, and a NotSupportedError exception MUST be thrown for any attempt to change it to a value greater than two.

ScriptProcessorNode

The channel count cannot be changed, and an NotSupportedError exception MUST be thrown for any attempt to change the value.

StereoPannerNode

The channel count cannot be greater than two, and a NotSupportedError exception MUST be thrown for any attempt to change it to a value greater than two.

See § 4 Channel Up-Mixing and Down-Mixing for more information on this attribute.

channelCountMode, of type ChannelCountMode

channelCountMode determines how channels will be counted when up-mixing and down-mixing connections to any inputs to the node. The default value is "max". This attribute has no effect for nodes with no inputs.

In addition, some nodes have additional channelCountMode constraints on the possible values for the channel count mode:

AudioDestinationNode

If the AudioDestinationNode is the destination node of an OfflineAudioContext, then the channel count mode cannot be changed. An InvalidStateError exception MUST be thrown for any attempt to change the value.

ChannelMergerNode

The channel count mode cannot be changed from "explicit" and an InvalidStateError exception MUST be thrown for any attempt to change the value.

ChannelSplitterNode

The channel count mode cannot be changed from "explicit" and an InvalidStateError exception MUST be thrown for any attempt to change the value.

ConvolverNode

The channel count mode cannot be set to "max", and a NotSupportedError exception MUST be thrown for any attempt to set it to "max".

DynamicsCompressorNode

The channel count mode cannot be set to "max", and a NotSupportedError exception MUST be thrown for any attempt to set it to "max".

PannerNode

The channel count mode cannot be set to "max", and a NotSupportedError exception MUST be thrown for any attempt to set it to "max".

ScriptProcessorNode

The channel count mode cannot be changed from "explicit" and an NotSupportedError exception MUST be thrown for any attempt to change the value.

StereoPannerNode

The channel count mode cannot be set to "max", and a NotSupportedError exception MUST be thrown for any attempt to set it to "max".

See the § 4 Channel Up-Mixing and Down-Mixing section for more information on this attribute.

channelInterpretation, of type ChannelInterpretation

channelInterpretation determines how individual channels will be treated when up-mixing and down-mixing connections to any inputs to the node. The default value is "speakers". This attribute has no effect for nodes with no inputs.

In addition, some nodes have additional channelInterpretation constraints on the possible values for the channel interpretation:

ChannelSplitterNode

The channel intepretation can not be changed from "discrete" and a InvalidStateError exception MUST be thrown for any attempt to change the value.

See § 4 Channel Up-Mixing and Down-Mixing for more information on this attribute.

context, of type BaseAudioContext, readonly

The BaseAudioContext which owns this AudioNode.

numberOfInputs, of type unsigned long, readonly

The number of inputs feeding into the AudioNode. For source nodes, this will be 0. This attribute is predetermined for many AudioNode types, but some AudioNodes, like the ChannelMergerNode and the AudioWorkletNode, have variable number of inputs.

numberOfOutputs, of type unsigned long, readonly

The number of outputs coming out of the AudioNode. This attribute is predetermined for some AudioNode types, but can be variable, like for the ChannelSplitterNode and the AudioWorkletNode.

connect(destinationNode, output, input)

There can only be one connection between a given output of one specific node and a given input of another specific node. Multiple connections with the same termini are ignored.

For example:

nodeA.connect(nodeB);
nodeA.connect(nodeB);

will have the same effect as

nodeA.connect(nodeB);

This method returns destination AudioNode object.

connect(destinationParam, output)

Connects the AudioNode to an AudioParam, controlling the parameter value with an a-rate signal.

It is possible to connect an AudioNode output to more than one AudioParam with multiple calls to connect(). Thus, "fan-out" is supported.

It is possible to connect more than one AudioNode output to a single AudioParam with multiple calls to connect(). Thus, "fan-in" is supported.

An AudioParam will take the rendered audio data from any AudioNode output connected to it and convert it to mono by down-mixing if it is not already mono, then mix it together with other such outputs and finally will mix with the intrinsic parameter value (the value the AudioParam would normally have without any audio connections), including any timeline changes scheduled for the parameter.

The down-mixing to mono is equivalent to the down-mixing for an AudioNode with channelCount = 1, channelCountMode = "explicit", and channelInterpretation = "speakers".

There can only be one connection between a given output of one specific node and a specific AudioParam. Multiple connections with the same termini are ignored.

For example:

nodeA.connect(param);
nodeA.connect(param);

will have the same effect as

nodeA.connect(param);

disconnect()

Disconnects all outgoing connections from the AudioNode.

No parameters.

disconnect(output)

Disconnects a single output of the AudioNode from any other AudioNode or AudioParam objects to which it is connected.

Arguments for the AudioNode.disconnect(output) method. Parameter Type Nullable Optional Description output unsigned long ✘ ✘ This parameter is an index describing which output of the AudioNode to disconnect. It disconnects all outgoing connections from the given output. If this parameter is out-of-bounds, an IndexSizeError exception MUST be thrown.

disconnect(destinationNode)

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

Arguments for the AudioNode.disconnect(destinationNode) method. Parameter Type Nullable Optional Description destinationNode The destinationNode parameter is the AudioNode to disconnect. It disconnects all outgoing connections to the given destinationNode. If there is no connection to the destinationNode, an InvalidAccessError exception MUST be thrown.

disconnect(destinationNode, output)

Disconnects a specific output of the AudioNode from any and all inputs of some destination AudioNode.

disconnect(destinationNode, output, input)

Disconnects a specific output of the AudioNode from a specific input of some destination AudioNode.

Arguments for the AudioNode.disconnect(destinationNode, output, input) method. Parameter Type Nullable Optional Description destinationNode The destinationNode parameter is the AudioNode to disconnect. If there is no connection to the destinationNode from the given output to the given input, an InvalidAccessError exception MUST be thrown. output unsigned long ✘ ✘ The output parameter is an index describing which output of the AudioNode from which to disconnect. If this parameter is out-of-bounds, an IndexSizeError exception MUST be thrown. input The input parameter is an index describing which input of the destination AudioNode to disconnect. If this parameter is out-of-bounds, an IndexSizeError exception MUST be thrown.

disconnect(destinationParam)

Disconnects all outputs of the AudioNode that go to a specific destination AudioParam. The contribution of this AudioNode to the computed parameter value goes to 0 when this operation takes effect. The intrinsic parameter value is not affected by this operation.

disconnect(destinationParam, output)

Disconnects a specific output of the AudioNode from a specific destination AudioParam. The contribution of this AudioNode to the computed parameter value goes to 0 when this operation takes effect. The intrinsic parameter value is not affected by this operation.

This specifies the options that can be used in constructing all AudioNodes. All members are optional. However, the specific values used for each node depends on the actual node.

dictionary AudioNodeOptions {
    unsigned long channelCount;
    ChannelCountMode channelCountMode;
    ChannelInterpretation channelInterpretation;
};

channelCount, of type unsigned long

Desired number of channels for the channelCount attribute.

channelCountMode, of type ChannelCountMode

Desired mode for the channelCountMode attribute.

channelInterpretation, of type ChannelInterpretation

Desired mode for the channelInterpretation attribute.

AudioParam controls an individual aspect of an AudioNode’s functionality, such as volume. The parameter can be set immediately to a particular value using the value attribute. Or, value changes can be scheduled to happen at very precise times (in the coordinate system of AudioContext’s currentTime attribute), for envelopes, volume fades, LFOs, filter sweeps, grain windows, etc. In this way, arbitrary timeline-based automation curves can be set on any AudioParam. Additionally, audio signals from the outputs of AudioNodes can be connected to an AudioParam, summing with the intrinsic parameter value.

Some synthesis and processing AudioNodes have AudioParams as attributes whose values MUST be taken into account on a per-audio-sample basis. For other AudioParams, sample-accuracy is not important and the value changes can be sampled more coarsely. Each individual AudioParam will specify that it is either an a-rate parameter which means that its values MUST be taken into account on a per-audio-sample basis, or it is a k-rate parameter.

Implementations MUST use block processing, with each AudioNode processing one render quantum.

For each render quantum, the value of a k-rate parameter MUST be sampled at the time of the very first sample-frame, and that value MUST be used for the entire block. a-rate parameters MUST be sampled for each sample-frame of the block. Depending on the AudioParam, its rate can be controlled by setting the automationRate attribute to either "a-rate" or "k-rate". See the description of the individual AudioParams for further details.

Each AudioParam includes minValue and maxValue attributes that together form the simple nominal range for the parameter. In effect, value of the parameter is clamped to the range \([\mathrm{minValue}, \mathrm{maxValue}]\). See § 1.6.3 Computation of Value for full details.

For many AudioParams the minValue and maxValue is intended to be set to the maximum possible range. In this case, maxValue should be set to the most-positive-single-float value, which is 3.4028235e38. (However, in JavaScript which only supports IEEE-754 double precision float values, this must be written as 3.4028234663852886e38.) Similarly, minValue should be set to the most-negative-single-float value, which is the negative of the most-positive-single-float: -3.4028235e38. (Similarly, this must be written in JavaScript as -3.4028234663852886e38.)

An AudioParam maintains a list of zero or more automation events. Each automation event specifies changes to the parameter’s value over a specific time range, in relation to its automation event time in the time coordinate system of the AudioContext’s currentTime attribute. The list of automation events is maintained in ascending order of automation event time.

The behavior of a given automation event is a function of the AudioContext’s current time, as well as the automation event times of this event and of adjacent events in the list. The following automation methods change the event list by adding a new event to the event list, of a type specific to the method:

• setValueAtTime() - SetValue

• linearRampToValueAtTime() - LinearRampToValue

• exponentialRampToValueAtTime() - ExponentialRampToValue

• setTargetAtTime() - SetTarget

• setValueCurveAtTime() - SetValueCurve

The following rules will apply when calling these methods:

• Automation event times are not quantized with respect to the prevailing sample rate. Formulas for determining curves and ramps are applied to the exact numerical times given when scheduling events.

• If one of these events is added at a time where there is already one or more events, then it will be placed in the list after them, but before events whose times are after the event.

• If setValueCurveAtTime() is called for time \(T\) and duration \(D\) and there are any events having a time strictly greater than \(T\), but strictly less than \(T + D\), then a NotSupportedError exception MUST be thrown. In other words, it’s not ok to schedule a value curve during a time period containing other events, but it’s ok to schedule a value curve exactly at the time of another event.

• Similarly a NotSupportedError exception MUST be thrown if any automation method is called at a time which is contained in \([T, T+D)\), \(T\) being the time of the curve and \(D\) its duration.

Note: AudioParam attributes are read only, with the exception of the value attribute.

The automation rate of an AudioParam can be selected setting the automationRate attribute with one of the following values. However, some AudioParams have constraints on whether the automation rate can be changed.

enum AutomationRate {
    "a-rate",
    "k-rate"
};

Each AudioParam has an internal slot [[current value]], initially set to the AudioParam’s defaultValue.

[Exposed=Window]
interface AudioParam {
    attribute float value;
    attribute AutomationRate automationRate;
    readonly attribute float defaultValue;
    readonly attribute float minValue;
    readonly attribute float maxValue;
    AudioParam setValueAtTime (float value, double startTime);
    AudioParam linearRampToValueAtTime (float value, double endTime);
    AudioParam exponentialRampToValueAtTime (float value, double endTime);
    AudioParam setTargetAtTime (float target, double startTime, float timeConstant);
    AudioParam setValueCurveAtTime (sequence<float> values,
                                    double startTime,
                                    double duration);
    AudioParam cancelScheduledValues (double cancelTime);
    AudioParam cancelAndHoldAtTime (double cancelTime);
};

automationRate, of type AutomationRate

The automation rate for the AudioParam. The default value depends on the actual AudioParam; see the description of each individual AudioParam for the default value.

Some nodes have additional automation rate constraints as follows:

AudioBufferSourceNode

The AudioParams playbackRate and detune MUST be "k-rate". An InvalidStateError must be thrown if the rate is changed to "a-rate".

DynamicsCompressorNode

The AudioParams threshold, knee, ratio, attack, and release MUST be "k-rate". An InvalidStateError must be thrown if the rate is changed to "a-rate".

PannerNode

If the panningModel is "HRTF", the setting of the automationRate for any AudioParam of the PannerNode is ignored. Likewise, the setting of the automationRate for any AudioParam of the AudioListener is ignored. In this case, the AudioParam behaves as if the automationRate were set to "k-rate".

defaultValue, of type float, readonly

Initial value for the value attribute.

maxValue, of type float, readonly

The nominal maximum value that the parameter can take. Together with minValue, this forms the nominal range for this parameter.

minValue, of type float, readonly

The nominal minimum value that the parameter can take. Together with maxValue, this forms the nominal range for this parameter.

value, of type float

The parameter’s floating-point value. This attribute is initialized to the defaultValue.

Getting this attribute returns the contents of the [[current value]] slot. See § 1.6.3 Computation of Value for the algorithm for the value that is returned.

Setting this attribute has the effect of assigning the requested value to the [[current value]] slot, and calling the setValueAtTime() method with the current AudioContext’s currentTime and [[current value]]. Any exceptions that would be thrown by setValueAtTime() will also be thrown by setting this attribute.

cancelAndHoldAtTime(cancelTime)

This is similar to cancelScheduledValues() in that it cancels all scheduled parameter changes with times greater than or equal to cancelTime. However, in addition, the automation value that would have happened at cancelTime is then propagated for all future time until other automation events are introduced.

The behavior of the timeline in the face of cancelAndHoldAtTime() when automations are running and can be introduced at any time after calling cancelAndHoldAtTime() and before cancelTime is reached is quite complicated. The behavior of cancelAndHoldAtTime() is therefore specified in the following algorithm.

Let \(t_c\) be the value of

cancelTime

. Then

1. Let \(E_1\) be the event (if any) at time \(t_1\) where \(t_1\) is the largest number satisfying \(t_1 \le t_c\).

2. Let \(E_2\) be the event (if any) at time \(t_2\) where \(t_2\) is the smallest number satisfying \(t_c \lt t_2\).

3. If \(E_2\) exists:

   1. If \(E_2\) is a linear or exponential ramp,

      1. Effectively rewrite \(E_2\) to be the same kind of ramp ending at time \(t_c\) with an end value that would be the value of the original ramp at time \(t_c\).

      2. Go to step 5.

   2. Otherwise, go to step 4.

4. If \(E_1\) exists:

   1. If \(E_1\) is a setTarget event,

      1. Implicitly insert a setValueAtTime event at time \(t_c\) with the value that the setTarget would have at time \(t_c\).

      2. Go to step 5.

   2. If \(E_1\) is a setValueCurve with a start time of \(t_3\) and a duration of \(d\)

      1. If \(t_c \gt t_3 + d\), go to step 5.

      2. Otherwise,

         1. Effectively replace this event with a setValueCurve event with a start time of \(t_3\) and a new duration of \(t_c-t_3\). However, this is not a true replacement; this automation MUST take care to produce the same output as the original, and not one computed using a different duration. (That would cause sampling of the value curve in a slightly different way, producing different results.)

         2. Go to step 5.

5. Remove all events with time greater than \(t_c\).

If no events are added, then the automation value after cancelAndHoldAtTime() is the constant value that the original timeline would have had at time \(t_c\).

cancelScheduledValues(cancelTime)

Cancels all scheduled parameter changes with times greater than or equal to cancelTime. Cancelling a scheduled parameter change means removing the scheduled event from the event list. Any active automations whose automation event time is less than cancelTime are also cancelled, and such cancellations may cause discontinuities because the original value (from before such automation) is restored immediately. Any hold values scheduled by cancelAndHoldAtTime() are also removed if the hold time occurs after cancelTime.

For a setValueCurveAtTime(), let \(T_0\) and \(T_D\) be the corresponding startTime and duration, respectively of this event. Then if cancelTime is in the range \([T_0, T_0 + T_D]\), the event is removed from the timeline.

exponentialRampToValueAtTime(value, endTime)

Schedules an exponential continuous change in parameter value from the previous scheduled parameter value to the given value. Parameters representing filter frequencies and playback rate are best changed exponentially because of the way humans perceive sound.

The value during the time interval \(T_0 \leq t < T_1\) (where \(T_0\) is the time of the previous event and \(T_1\) is the endTime parameter passed into this method) will be calculated as:

$$
    v(t) = V_0 \left(\frac{V_1}{V_0}\right)^\frac{t - T_0}{T_1 - T_0}
$$

where \(V_0\) is the value at the time \(T_0\) and \(V_1\) is the value parameter passed into this method. If \(V_0\) and \(V_1\) have opposite signs or if \(V_0\) is zero, then \(v(t) = V_0\) for \(T_0 \le t \lt T_1\).

This also implies an exponential ramp to 0 is not possible. A good approximation can be achieved using setTargetAtTime() with an appropriately chosen time constant.

If there are no more events after this ExponentialRampToValue event then for \(t \geq T_1\), \(v(t) = V_1\).

If there is no event preceding this event, the exponential ramp behaves as if setValueAtTime(value, currentTime) were called where value is the current value of the attribute and currentTime is the context currentTime at the time exponentialRampToValueAtTime() is called.

If the preceding event is a SetTarget event, \(T_0\) and \(V_0\) are chosen from the current time and value of SetTarget automation. That is, if the SetTarget event has not started, \(T_0\) is the start time of the event, and \(V_0\) is the value just before the SetTarget event starts. In this case, the ExponentialRampToValue event effectively replaces the SetTarget event. If the SetTarget event has already started, \(T_0\) is the current context time, and \(V_0\) is the current SetTarget automation value at time \(T_0\). In both cases, the automation curve is continuous.

linearRampToValueAtTime(value, endTime)

Schedules a linear continuous change in parameter value from the previous scheduled parameter value to the given value.

The value during the time interval \(T_0 \leq t < T_1\) (where \(T_0\) is the time of the previous event and \(T_1\) is the endTime parameter passed into this method) will be calculated as:

$$
    v(t) = V_0 + (V_1 - V_0) \frac{t - T_0}{T_1 - T_0}
$$

where \(V_0\) is the value at the time \(T_0\) and \(V_1\) is the value parameter passed into this method.

If there are no more events after this LinearRampToValue event then for \(t \geq T_1\), \(v(t) = V_1\).

If there is no event preceding this event, the linear ramp behaves as if setValueAtTime(value, currentTime) were called where value is the current value of the attribute and currentTime is the context currentTime at the time linearRampToValueAtTime() is called.

If the preceding event is a SetTarget event, \(T_0\) and \(V_0\) are chosen from the current time and value of SetTarget automation. That is, if the SetTarget event has not started, \(T_0\) is the start time of the event, and \(V_0\) is the value just before the SetTarget event starts. In this case, the LinearRampToValue event effectively replaces the SetTarget event. If the SetTarget event has already started, \(T_0\) is the current context time, and \(V_0\) is the current SetTarget automation value at time \(T_0\). In both cases, the automation curve is continuous.

setTargetAtTime(target, startTime, timeConstant)

Start exponentially approaching the target value at the given time with a rate having the given time constant. Among other uses, this is useful for implementing the "decay" and "release" portions of an ADSR envelope. Please note that the parameter value does not immediately change to the target value at the given time, but instead gradually changes to the target value.

During the time interval: \(T_0 \leq t\), where \(T_0\) is the startTime parameter:

$$
    v(t) = V_1 + (V_0 - V_1)\, e^{-\left(\frac{t - T_0}{\tau}\right)}
$$

where \(V_0\) is the initial value (the [[current value]] attribute) at \(T_0\) (the startTime parameter), \(V_1\) is equal to the target parameter, and \(\tau\) is the timeConstant parameter.

If a LinearRampToValue or ExponentialRampToValue event follows this event, the behavior is described in linearRampToValueAtTime() or exponentialRampToValueAtTime(), respectively. For all other events, the SetTarget event ends at the time of the next event.

Arguments for the AudioParam.setTargetAtTime() method. Parameter Type Nullable Optional Description target float ✘ ✘ The value the parameter will start changing to at the given time. startTime double ✘ ✘ The time at which the exponential approach will begin, in the same time coordinate system as the AudioContext’s currentTime attribute. A RangeError exception MUST be thrown if start is negative or is not a finite number. If startTime is less than currentTime, it is clamped to currentTime. timeConstant float ✘ ✘ The time-constant value of first-order filter (exponential) approach to the target value. The larger this value is, the slower the transition will be. The value MUST be non-negative or a RangeError exception MUST be thrown. If timeConstant is zero, the output value jumps immediately to the final value. More precisely, timeConstant is the time it takes a first-order linear continuous time-invariant system to reach the value \(1 - 1/e\) (around 63.2%) given a step input response (transition from 0 to 1 value).

setValueAtTime(value, startTime)

Schedules a parameter value change at the given time.

If there are no more events after this SetValue event, then for \(t \geq T_0\), \(v(t) = V\), where \(T_0\) is the startTime parameter and \(V\) is the value parameter. In other words, the value will remain constant.

If the next event (having time \(T_1\)) after this SetValue event is not of type LinearRampToValue or ExponentialRampToValue, then, for \(T_0 \leq t < T_1\):

$$
    v(t) = V
$$

In other words, the value will remain constant during this time interval, allowing the creation of "step" functions.

If the next event after this SetValue event is of type LinearRampToValue or ExponentialRampToValue then please see linearRampToValueAtTime() or exponentialRampToValueAtTime(), respectively.

Arguments for the AudioParam.setValueAtTime() method. Parameter Type Nullable Optional Description value float ✘ ✘ The value the parameter will change to at the given time. startTime double ✘ ✘ The time in the same time coordinate system as the BaseAudioContext’s currentTime attribute at which the parameter changes to the given value. A RangeError exception MUST be thrown if startTime is negative or is not a finite number. If startTime is less than currentTime, it is clamped to currentTime.

setValueCurveAtTime(values, startTime, duration)

Sets an array of arbitrary parameter values starting at the given time for the given duration. The number of values will be scaled to fit into the desired duration.

Let \(T_0\) be startTime, \(T_D\) be duration, \(V\) be the values array, and \(N\) be the length of the values array. Then, during the time interval: \(T_0 \le t < T_0 + T_D\), let

$$
    \begin{align*} k &= \left\lfloor \frac{N - 1}{T_D}(t-T_0) \right\rfloor \\
    \end{align*}
$$

Then \(v(t)\) is computed by linearly interpolating between \(V[k]\) and \(V[k+1]\),

After the end of the curve time interval (\(t \ge T_0 + T_D\)), the value will remain constant at the final curve value, until there is another automation event (if any).

An implicit call to setValueAtTime() is made at time \(T_0 + T_D\) with value \(V[N-1]\) so that following automations will start from the end of the setValueCurveAtTime() event.

Arguments for the AudioParam.setValueCurveAtTime() method. Parameter Type Nullable Optional Description values sequence<float> ✘ ✘ A sequence of float values representing a parameter value curve. These values will apply starting at the given time and lasting for the given duration. When this method is called, an internal copy of the curve is created for automation purposes. Subsequent modifications of the contents of the passed-in array therefore have no effect on the AudioParam. An InvalidStateError MUST be thrown if this attribute is a sequence<float> object that has a length less than 2. startTime double ✘ ✘ The start time in the same time coordinate system as the AudioContext’s currentTime attribute at which the value curve will be applied. A RangeError exception MUST be thrown if startTime is negative or is not a finite number. If startTime is less than currentTime, it is clamped to currentTime. duration double ✘ ✘ The amount of time in seconds (after the startTime parameter) where values will be calculated according to the values parameter. A RangeError exception MUST be thrown if duration is not strictly positive or is not a finite number.

There are two different kind of AudioParams, simple parameters and compound parameters. Simple parameters (the default) are used on their own to compute the final audio output of an AudioNode. Compound parameters are AudioParams that are used with other AudioParams to compute a value that is then used as an input to compute the output of an AudioNode.

The computedValue is the final value controlling the audio DSP and is computed by the audio rendering thread during each rendering time quantum.

The computation of the value of an

consists of two parts:

• the paramIntrinsicValue value that is computed from the value attribute and any automation events.

• the paramComputedValue that is the final value controlling the audio DSP and is computed by the audio rendering thread during each render quantum.

These values MUST be computed as follows:

1. paramIntrinsicValue will be calculated at each time, which is either the value set directly to the value attribute, or, if there are any automation events with times before or at this time, the value as calculated from these events. If automation events are removed from a given time range, then the paramIntrinsicValue value will remain unchanged and stay at its previous value until either the value attribute is directly set, or automation events are added for the time range.

2. Set [[current value]] to the value of paramIntrinsicValue at the beginning of this render quantum.

3. paramComputedValue is the sum of the paramIntrinsicValue value and the value of the input AudioParam buffer. If the sum is NaN, replace the sum with the defaultValue.

4. If this AudioParam is a compound parameter, compute its final value with other AudioParams.

5. Set computedValue to paramComputedValue.

The nominal range for a computedValue are the lower and higher values this parameter can effectively have. For simple parameters, the computedValue is clamped to the simple nominal range for this parameter. Compound parameters have their final value clamped to their nominal range after having been computed from the different AudioParam values they are composed of.

When automation methods are used, clamping is still applied. However, the automation is run as if there were no clamping at all. Only when the automation values are to be applied to the output is the clamping done as specified above.

For example, consider a node \(N\) has an AudioParam \(p\) with a nominal range of \([0, 1]\), and following automation sequence

N.p.setValueAtTime(0, 0);
N.p.linearRampToValueAtTime(4, 1);
N.p.linearRampToValueAtTime(0, 2);

The initial slope of the curve is 4, until it reaches the maximum value of 1, at which time, the output is held constant. Finally, near time 2, the slope of the curve is -4. This is illustrated in the graph below where the dashed line indicates what would have happened without clipping, and the solid line indicates the actual expected behavior of the audioparam due to clipping to the nominal range.

const curveLength = 44100;const curve = new Float32Array(curveLength);for (const i = 0; i < curveLength; ++i)    curve[i] = Math.sin(Math.PI * i / curveLength);const t0 = 0;const t1 = 0.1;const t2 = 0.2;const t3 = 0.3;const t4 = 0.325;const t5 = 0.5;const t6 = 0.6;const t7 = 0.7;const t8 = 1.0;const timeConstant = 0.1;param.setValueAtTime(0.2, t0);param.setValueAtTime(0.3, t1);param.setValueAtTime(0.4, t2);param.linearRampToValueAtTime(1, t3);param.linearRampToValueAtTime(0.8, t4);param.setTargetAtTime(.5, t4, timeConstant);// Compute where the setTargetAtTime will be at time t5 so we can make// the following exponential start at the right point so there’s no// jump discontinuity. From the spec, we have// v(t) = 0.5 + (0.8 - 0.5)*exp(-(t-t4)/timeConstant)// Thus v(t5) = 0.5 + (0.8 - 0.5)*exp(-(t5-t4)/timeConstant)param.setValueAtTime(0.5 + (0.8 - 0.5)*Math.exp(-(t5 - t4)/timeConstant), t5);param.exponentialRampToValueAtTime(0.75, t6);param.exponentialRampToValueAtTime(0.05, t7);param.setValueCurveAtTime(curve, t7, t8 - t7);

The interface represents the common features of source nodes such as AudioBufferSourceNode, ConstantSourceNode, and OscillatorNode.

Before a source is started (by calling start(), the source node MUST output silence (0). After a source has been stopped (by calling stop()), the source MUST then output silence (0).

AudioScheduledSourceNode cannot be instantiated directly, but is instead extended by the concrete interfaces for the source nodes.

An AudioScheduledSourceNode is said to be playing when its associated BaseAudioContext’s currentTime is greater or equal to the time the AudioScheduledSourceNode is set to start, and less than the time it’s set to stop.

AudioScheduledSourceNodes are created with an internal boolean slot [[source started]], initially set to false.

[Exposed=Window]
interface AudioScheduledSourceNode : AudioNode {
    attribute EventHandler onended;
    undefined start(optional double when = 0);
    undefined stop(optional double when = 0);
};

onended, of type EventHandler

A property used to set an event handler for the ended event type that is dispatched to AudioScheduledSourceNode node types. When the source node has stopped playing (as determined by the concrete node), an event that uses the Event interface will be dispatched to the event handler.

For all AudioScheduledSourceNodes, the ended event is dispatched when the stop time determined by stop() is reached. For an AudioBufferSourceNode, the event is also dispatched because the duration has been reached or if the entire buffer has been played.

start(when)

Schedules a sound to playback at an exact time.

Arguments for the AudioScheduledSourceNode.start(when) method. Parameter Type Nullable Optional Description when double ✘ ✔ The when parameter describes at what time (in seconds) the sound should start playing. It is in the same time coordinate system as the AudioContext’s currentTime attribute. When the signal emitted by the AudioScheduledSourceNode depends on the sound’s start time, the exact value of when is always used without rounding to the nearest sample frame. If 0 is passed in for this value or if the value is less than currentTime, then the sound will start playing immediately. A RangeError exception MUST be thrown if when is negative.

stop(when)

Schedules a sound to stop playback at an exact time. If stop is called again after already having been called, the last invocation will be the only one applied; stop times set by previous calls will not be applied, unless the buffer has already stopped prior to any subsequent calls. If the buffer has already stopped, further calls to stop will have no effect. If a stop time is reached prior to the scheduled start time, the sound will not play.

Arguments for the AudioScheduledSourceNode.stop(when) method. Parameter Type Nullable Optional Description when double ✘ ✔ The when parameter describes at what time (in seconds) the source should stop playing. It is in the same time coordinate system as the AudioContext’s currentTime attribute. If 0 is passed in for this value or if the value is less than currentTime, then the sound will stop playing immediately. A RangeError exception MUST be thrown if when is negative.

This interface represents a node which is able to provide real-time frequency and time-domain analysis information. The audio stream will be passed un-processed from input to output.

[Exposed=Window]
interface AnalyserNode : AudioNode {
    constructor (BaseAudioContext context, optional AnalyserOptions options = {});
    undefined getFloatFrequencyData (Float32Array array);
    undefined getByteFrequencyData (Uint8Array array);
    undefined getFloatTimeDomainData (Float32Array array);
    undefined getByteTimeDomainData (Uint8Array array);
    attribute unsigned long fftSize;
    readonly attribute unsigned long frequencyBinCount;
    attribute double minDecibels;
    attribute double maxDecibels;
    attribute double smoothingTimeConstant;
};

AnalyserNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

fftSize, of type unsigned long

The size of the FFT used for frequency-domain analysis (in sample-frames). This MUST be a power of two in the range 32 to 32768, otherwise an IndexSizeError exception MUST be thrown. The default value is 2048. Note that large FFT sizes can be costly to compute.

If the fftSize is changed to a different value, then all state associated with smoothing of the frequency data (for getByteFrequencyData() and getFloatFrequencyData()) is reset. That is the previous block, \(\hat{X}_{-1}[k]\), used for smoothing over time is set to 0 for all \(k\).

Note that increasing fftSize does mean that the current time-domain data must be expanded to include past frames that it previously did not. This means that the AnalyserNode effectively MUST keep around the last 32768 sample-frames and the current time-domain data is the most recent fftSize sample-frames out of that.

frequencyBinCount, of type unsigned long, readonly

Half the FFT size.

maxDecibels, of type double

maxDecibels is the maximum power value in the scaling range for the FFT analysis data for conversion to unsigned byte values. The default value is -30. If the value of this attribute is set to a value less than or equal to minDecibels, an IndexSizeError exception MUST be thrown.

minDecibels, of type double

minDecibels is the minimum power value in the scaling range for the FFT analysis data for conversion to unsigned byte values. The default value is -100. If the value of this attribute is set to a value more than or equal to maxDecibels, an IndexSizeError exception MUST be thrown.

smoothingTimeConstant, of type double

A value from 0 -> 1 where 0 represents no time averaging with the last analysis frame. The default value is 0.8. If the value of this attribute is set to a value less than 0 or more than 1, an IndexSizeError exception MUST be thrown.

getByteFrequencyData(array)

Write the current frequency data into array. If array’s byte length is less than frequencyBinCount, the excess elements will be dropped. If array’s byte length is greater than the frequencyBinCount, the excess elements will be ignored. The most recent fftSize frames are used in computing the frequency data.

If another call to getByteFrequencyData() or getFloatFrequencyData() occurs within the same render quantum as a previous call, the current frequency data is not updated with the same data. Instead, the previously computed data is returned.

The values stored in the unsigned byte array are computed in the following way. Let \(Y[k]\) be the current frequency data as described in FFT windowing and smoothing. Then the byte value, \(b[k]\), is

$$
    b[k] = \left\lfloor
            \frac{255}{\mbox{dB}_{max} - \mbox{dB}_{min}}
            \left(Y[k] - \mbox{dB}_{min}\right)
        \right\rfloor
$$

where \(\mbox{dB}_{min}\) is minDecibels and \(\mbox{dB}_{max}\) is maxDecibels. If \(b[k]\) lies outside the range of 0 to 255, \(b[k]\) is clipped to lie in that range.

getByteTimeDomainData(array)

Write the current time-domain data (waveform data) into array. If array’s byte length is less than fftSize, the excess elements will be dropped. If array’s byte length is greater than the fftSize, the excess elements will be ignored. The most recent fftSize frames are used in computing the byte data.

The values stored in the unsigned byte array are computed in the following way. Let \(x[k]\) be the time-domain data. Then the byte value, \(b[k]\), is

$$
    b[k] = \left\lfloor 128(1 + x[k]) \right\rfloor.
$$

If \(b[k]\) lies outside the range 0 to 255, \(b[k]\) is clipped to lie in that range.

getFloatFrequencyData(array)

Write the current frequency data into array. If array has fewer elements than the frequencyBinCount, the excess elements will be dropped. If array has more elements than the frequencyBinCount, the excess elements will be ignored. The most recent fftSize frames are used in computing the frequency data.

If another call to getFloatFrequencyData() or getByteFrequencyData() occurs within the same render quantum as a previous call, the current frequency data is not updated with the same data. Instead, the previously computed data is returned.

The frequency data are in dB units.

getFloatTimeDomainData(array)

Write the current time-domain data (waveform data) into array. If array has fewer elements than the value of fftSize, the excess elements will be dropped. If array has more elements than the value of fftSize, the excess elements will be ignored. The most recent fftSize frames are written (after downmixing).

This specifies the options to be used when constructing an AnalyserNode. All members are optional; if not specified, the normal default values are used to construct the node.

dictionary AnalyserOptions : AudioNodeOptions {
    unsigned long fftSize = 2048;
    double maxDecibels = -30;
    double minDecibels = -100;
    double smoothingTimeConstant = 0.8;
};

fftSize, of type unsigned long, defaulting to 2048

The desired initial size of the FFT for frequency-domain analysis.

maxDecibels, of type double, defaulting to -30

The desired initial maximum power in dB for FFT analysis.

minDecibels, of type double, defaulting to -100

The desired initial minimum power in dB for FFT analysis.

smoothingTimeConstant, of type double, defaulting to 0.8

The desired initial smoothing constant for the FFT analysis.

When the current time-domain data are computed, the input signal must be down-mixed to mono as if channelCount is 1, channelCountMode is "max" and channelInterpretation is "speakers". This is independent of the settings for the AnalyserNode itself. The most recent fftSize frames are used for the down-mixing operation.

When the current frequency data are computed, the following operations are to be performed:

In the following, let \(N\) be the value of the fftSize attribute of this AnalyserNode.

consists in the following operation on the input time domain data. Let \(x[n]\) for \(n = 0, \ldots, N - 1\) be the time domain data. The Blackman window is defined by

$$
\begin{align*}
    \alpha &= \mbox{0.16} \\ a_0 &= \frac{1-\alpha}{2} \\
    a_1 &= \frac{1}{2} \\
    a_2 &= \frac{\alpha}{2} \\
    w[n] &= a_0 - a_1 \cos\frac{2\pi n}{N} + a_2 \cos\frac{4\pi n}{N}, \mbox{ for } n = 0, \ldots, N - 1
\end{align*}
$$

The windowed signal \(\hat{x}[n]\) is

$$
    \hat{x}[n] = x[n] w[n], \mbox{ for } n = 0, \ldots, N - 1
$$

consists of computing the Fourier transform in the following way. Let \(X[k]\) be the complex frequency domain data and \(\hat{x}[n]\) be the windowed time domain data computed above. Then

$$
    X[k] = \frac{1}{N} \sum_{n = 0}^{N - 1} \hat{x}[n]\, W^{-kn}_{N}
$$

for \(k = 0, \dots, N/2-1\) where \(W_N = e^{2\pi i/N}\).

frequency data consists in the following operation:

• Let \(\hat{X}_{-1}[k]\) be the result of this operation on the previous block. The previous block is defined as being the buffer computed by the previous smoothing over time operation, or an array of \(N\) zeros if this is the first time we are smoothing over time.

• Let \(\tau\) be the value of the smoothingTimeConstant attribute for this AnalyserNode.

• Let \(X[k]\) be the result of applying a Fourier transform of the current block.

Then the smoothed value, \(\hat{X}[k]\), is computed by

$$
    \hat{X}[k] = \tau\, \hat{X}_{-1}[k] + (1 - \tau)\, \left|X[k]\right|
$$

• If \(\hat{X}[k]\) is NaN, positive infinity or negative infinity, set \(\hat{X}[k]\) = 0.

for \(k = 0, \ldots, N - 1\).

This interface represents an audio source from an in-memory audio asset in an AudioBuffer. It is useful for playing audio assets which require a high degree of scheduling flexibility and accuracy. If sample-accurate playback of network- or disk-backed assets is required, an implementer should use AudioWorkletNode to implement playback.

The start() method is used to schedule when sound playback will happen. The start() method may not be issued multiple times. The playback will stop automatically when the buffer’s audio data has been completely played (if the loop attribute is false), or when the stop() method has been called and the specified time has been reached. Please see more details in the start() and stop() descriptions.

The number of channels of the output equals the number of channels of the AudioBuffer assigned to the buffer attribute, or is one channel of silence if buffer is null.

In addition, if the buffer has more than one channel, then the AudioBufferSourceNode output must change to a single channel of silence at the beginning of a render quantum after the time at which any one of the following conditions holds:

• the end of the buffer has been reached;

• the duration has been reached;

• the stop time has been reached.

A playhead position for an AudioBufferSourceNode is defined as any quantity representing a time offset in seconds, relative to the time coordinate of the first sample frame in the buffer. Such values are to be considered independently from the node’s playbackRate and detune parameters. In general, playhead positions may be subsample-accurate and need not refer to exact sample frame positions. They may assume valid values between 0 and the duration of the buffer.

The playbackRate and detune attributes form a compound parameter. They are used together to determine a computedPlaybackRate value:

computedPlaybackRate(t) = playbackRate(t) * pow(2, detune(t) / 1200)

The nominal range for this compound parameter is \((-\infty, \infty)\).

AudioBufferSourceNodes are created with an internal boolean slot [[buffer set]], initially set to false.

[Exposed=Window]
interface AudioBufferSourceNode : AudioScheduledSourceNode {
    constructor (BaseAudioContext context,
                 optional AudioBufferSourceOptions options = {});
    attribute AudioBuffer? buffer;
    readonly attribute AudioParam playbackRate;
    readonly attribute AudioParam detune;
    attribute boolean loop;
    attribute double loopStart;
    attribute double loopEnd;
    undefined start (optional double when = 0,
                     optional double offset,
                     optional double duration);
};

AudioBufferSourceNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

buffer, of type AudioBuffer, nullable

Represents the audio asset to be played.

detune, of type AudioParam, readonly

An additional parameter, in cents, to modulate the speed at which is rendered the audio stream. This parameter is a compound parameter with playbackRate to form a computedPlaybackRate.

loop, of type boolean

Indicates if the region of audio data designated by loopStart and loopEnd should be played continuously in a loop. The default value is false.

loopEnd, of type double

An optional playhead position where looping should end if the loop attribute is true. Its value is exclusive of the content of the loop. Its default value is 0, and it may usefully be set to any value between 0 and the duration of the buffer. If loopEnd is less than or equal to 0, or if loopEnd is greater than the duration of the buffer, looping will end at the end of the buffer.

loopStart, of type double

An optional playhead position where looping should begin if the loop attribute is true. Its default value is 0, and it may usefully be set to any value between 0 and the duration of the buffer. If loopStart is less than 0, looping will begin at 0. If loopStart is greater than the duration of the buffer, looping will begin at the end of the buffer.

playbackRate, of type AudioParam, readonly

The speed at which to render the audio stream. This is a compound parameter with detune to form a computedPlaybackRate.

start(when, offset, duration)

Schedules a sound to playback at an exact time.

Arguments for the AudioBufferSourceNode.start(when, offset, duration) method. Parameter Type Nullable Optional Description when double ✘ ✔ The when parameter describes at what time (in seconds) the sound should start playing. It is in the same time coordinate system as the AudioContext’s currentTime attribute. If 0 is passed in for this value or if the value is less than currentTime, then the sound will start playing immediately. A RangeError exception MUST be thrown if when is negative. offset double ✘ ✔ The offset parameter supplies a playhead position where playback will begin. If 0 is passed in for this value, then playback will start from the beginning of the buffer. A RangeError exception MUST be thrown if offset is negative. If offset is greater than loopEnd, playbackRate is positive or zero, and loop is true, playback will begin at loopEnd. If offset is greater than loopStart, playbackRate is negative, and loop is true, playback will begin at loopStart. offset is silently clamped to [0, duration], when startTime is reached, where duration is the value of the duration attribute of the AudioBuffer set to the buffer attribute of this AudioBufferSourceNode. duration double ✘ ✔ The duration parameter describes the duration of sound to be played, expressed as seconds of total buffer content to be output, including any whole or partial loop iterations. The units of duration are independent of the effects of playbackRate. For example, a duration of 5 seconds with a playback rate of 0.5 will output 5 seconds of buffer content at half speed, producing 10 seconds of audible output. A RangeError exception MUST be thrown if duration is negative.

This specifies options for constructing a AudioBufferSourceNode. All members are optional; if not specified, the normal default is used in constructing the node.

dictionary AudioBufferSourceOptions {
    AudioBuffer? buffer;
    float detune = 0;
    boolean loop = false;
    double loopEnd = 0;
    double loopStart = 0;
    float playbackRate = 1;
};

buffer, of type AudioBuffer, nullable

The audio asset to be played. This is equivalent to assigning buffer to the buffer attribute of the AudioBufferSourceNode.

detune, of type float, defaulting to 0

The initial value for the detune AudioParam.

loop, of type boolean, defaulting to false

The initial value for the loop attribute.

loopEnd, of type double, defaulting to 0

The initial value for the loopEnd attribute.

loopStart, of type double, defaulting to 0

The initial value for the loopStart attribute.

playbackRate, of type float, defaulting to 1

The initial value for the playbackRate AudioParam.

This section is non-normative. Please see the playback algorithm for normative requirements.

Setting the loop attribute to true causes playback of the region of the buffer defined by the endpoints loopStart and loopEnd to continue indefinitely, once any part of the looped region has been played. While loop remains true, looped playback will continue until one of the following occurs:

• stop() is called,

• the scheduled stop time has been reached,

• the duration has been exceeded, if start() was called with a duration value.

The body of the loop is considered to occupy a region from loopStart up to, but not including, loopEnd. The direction of playback of the looped region respects the sign of the node’s playback rate. For positive playback rates, looping occurs from loopStart to loopEnd; for negative rates, looping occurs from loopEnd to loopStart.

Looping does not affect the interpretation of the offset argument of start(). Playback always starts at the requested offset, and looping only begins once the body of the loop is encountered during playback.

The effective loop start and end points are required to lie within the range of zero and the buffer duration, as specified in the algorithm below. loopEnd is further constrained to be at or after loopStart. If any of these constraints are violated, the loop is considered to include the entire buffer contents.

Loop endpoints have subsample accuracy. When endpoints do not fall on exact sample frame offsets, or when the playback rate is not equal to 1, playback of the loop is interpolated to splice the beginning and end of the loop together just as if the looped audio occurred in sequential, non-looped regions of the buffer.

Loop-related properties may be varied during playback of the buffer, and in general take effect on the next rendering quantum. The exact results are defined by the normative playback algorithm which follows.

The default values of the loopStart and loopEnd attributes are both 0. Since a loopEnd value of zero is equivalent to the length of the buffer, the default endpoints cause the entire buffer to be included in the loop.

Note that the values of the loop endpoints are expressed as time offsets in terms of the sample rate of the buffer, meaning that these values are independent of the node’s playbackRate parameter which can vary dynamically during the course of playback.

This normative section specifies the playback of the contents of the buffer, accounting for the fact that playback is influenced by the following factors working in combination:

• A starting offset, which can be expressed with sub-sample precision.

• Loop points, which can be expressed with sub-sample precision and can vary dynamically during playback.

• Playback rate and detuning parameters, which combine to yield a single computedPlaybackRate that can assume finite values which may be positive or negative.

The algorithm to be followed internally to generate output from an AudioBufferSourceNode conforms to the following principles:

• Resampling of the buffer may be performed arbitrarily by the UA at any desired point to increase the efficiency or quality of the output.

• Sub-sample start offsets or loop points may require additional interpolation between sample frames.

• The playback of a looped buffer should behave identically to an unlooped buffer containing consecutive occurrences of the looped audio content, excluding any effects from interpolation.

The description of the algorithm is as follows:

let buffer; // AudioBuffer employed by this nodelet context; // AudioContext employed by this node// The following variables capture attribute and AudioParam values for the node.// They are updated on a k-rate basis, prior to each invocation of process().let loop;let detune;let loopStart;let loopEnd;let playbackRate;// Variables for the node's playback parameterslet start = 0, offset = 0, duration = Infinity; // Set by start()let stop = Infinity; // Set by stop()// Variables for tracking node's playback statelet bufferTime = 0, started = false, enteredLoop = false;let bufferTimeElapsed = 0;let dt = 1 / context.sampleRate;// Handle invocation of start method callfunction handleStart(when, pos, dur) {    if (arguments.length >= 1) {        start = when;    }    offset = pos;    if (arguments.length >= 3) {        duration = dur;    }}// Handle invocation of stop method callfunction handleStop(when) {    if (arguments.length >= 1) {        stop = when;    } else {        stop = context.currentTime;    }}// Interpolate a multi-channel signal value for some sample frame.// Returns an array of signal values.function playbackSignal(position) {    /*        This function provides the playback signal function for buffer, which is a        function that maps from a playhead position to a set of output signal        values, one for each output channel. If |position| corresponds to the        location of an exact sample frame in the buffer, this function returns        that frame. Otherwise, its return value is determined by a UA-supplied        algorithm that interpolates sample frames in the neighborhood of        |position|.        If |position| is greater than or equal to |loopEnd| and there is no subsequent        sample frame in buffer, then interpolation should be based on the sequence        of subsequent frames beginning at |loopStart|.     */     ...}// Generate a single render quantum of audio to be placed// in the channel arrays defined by output. Returns an array// of |numberOfFrames| sample frames to be output.function process(numberOfFrames) {    let currentTime = context.currentTime; // context time of next rendered frame    const output = []; // accumulates rendered sample frames    // Combine the two k-rate parameters affecting playback rate    const computedPlaybackRate = playbackRate * Math.pow(2, detune / 1200);    // Determine loop endpoints as applicable    let actualLoopStart, actualLoopEnd;    if (loop && buffer != null) {        if (loopStart >= 0 && loopEnd > 0 && loopStart < loopEnd) {            actualLoopStart = loopStart;            actualLoopEnd = Math.min(loopEnd, buffer.duration);        } else {            actualLoopStart = 0;            actualLoopEnd = buffer.duration;        }    } else {        // If the loop flag is false, remove any record of the loop having been entered        enteredLoop = false;    }    // Handle null buffer case    if (buffer == null) {        stop = currentTime; // force zero output for all time    }    // Render each sample frame in the quantum    for (let index = 0; index < numberOfFrames; index++) {        // Check that currentTime and bufferTimeElapsed are        // within allowable range for playback        if (currentTime < start || currentTime >= stop || bufferTimeElapsed >= duration) {            output.push(0); // this sample frame is silent            currentTime += dt;            continue;        }        if (!started) {            // Take note that buffer has started playing and get initial            // playhead position.            if (loop && computedPlaybackRate >= 0 && offset >= actualLoopEnd) {                offset = actualLoopEnd;            }            if (computedPlaybackRate < 0 && loop && offset < actualLoopStart) {                offset = actualLoopStart;            }            bufferTime = offset;            started = true;        }        // Handle loop-related calculations        if (loop) {            // Determine if looped portion has been entered for the first time            if (!enteredLoop) {                if (offset < actualLoopEnd && bufferTime >= actualLoopStart) {                    // playback began before or within loop, and playhead is                    // now past loop start                    enteredLoop = true;                }                if (offset >= actualLoopEnd && bufferTime < actualLoopEnd) {                    // playback began after loop, and playhead is now prior                    // to the loop end                    enteredLoop = true;                }            }            // Wrap loop iterations as needed. Note that enteredLoop            // may become true inside the preceding conditional.            if (enteredLoop) {                while (bufferTime >= actualLoopEnd) {                    bufferTime -= actualLoopEnd - actualLoopStart;                }                while (bufferTime < actualLoopStart) {                    bufferTime += actualLoopEnd - actualLoopStart;                }            }        }        if (bufferTime >= 0 && bufferTime < buffer.duration) {            output.push(playbackSignal(bufferTime));        } else {            output.push(0); // past end of buffer, so output silent frame        }        bufferTime += dt * computedPlaybackRate;        bufferTimeElapsed += dt * computedPlaybackRate;        currentTime += dt;    } // End of render quantum loop    if (currentTime >= stop) {        // End playback state of this node.  No further invocations of process()        // will occur.  Schedule a change to set the number of output channels to 1.    }    return output;}

The following non-normative figures illustrate the behavior of the algorithm in assorted key scenarios. Dynamic resampling of the buffer is not considered, but as long as the times of loop positions are not changed this does not materially affect the resulting playback. In all figures, the following conventions apply:

• context sample rate is 1000 Hz

• AudioBuffer content is shown with the first sample frame at the x origin.

• output signals are shown with the sample frame located at time start at the x origin.

• linear interpolation is depicted throughout, although a UA could employ other interpolation techniques.

• the duration values noted in the figures refer to the buffer, not arguments to start()

This figure illustrates basic playback of a buffer, with a simple loop that ends after the last sample frame in the buffer:

This figure illustrates playbackRate interpolation, showing half-speed playback of buffer contents in which every other output sample frame is interpolated. Of particular note is the last sample frame in the looped output, which is interpolated using the loop start point:

This figure illustrates sample rate interpolation, showing playback of a buffer whose sample rate is 50% of the context sample rate, resulting in a computed playback rate of 0.5 that corrects for the difference in sample rate between the buffer and the context. The resulting output is the same as the preceding example, but for different reasons.

This figure illustrates subsample offset playback, in which the offset within the buffer begins at exactly half a sample frame. Consequently, every output frame is interpolated:

This figure illustrates subsample loop playback, showing how fractional frame offsets in the loop endpoints map to interpolated data points in the buffer that respect these offsets as if they were references to exact sample frames:

This is an AudioNode representing the final audio destination and is what the user will ultimately hear. It can often be considered as an audio output device which is connected to speakers. All rendered audio to be heard will be routed to this node, a "terminal" node in the AudioContext’s routing graph. There is only a single AudioDestinationNode per AudioContext, provided through the destination attribute of AudioContext.

The output of a AudioDestinationNode is produced by summing its input, allowing to capture the output of an AudioContext into, for example, a MediaStreamAudioDestinationNode, or a MediaRecorder (described in [mediastream-recording]).

The AudioDestinationNode can be either the destination of an AudioContext or OfflineAudioContext, and the channel properties depend on what the context is.

For an AudioContext, the defaults are

The channelCount can be set to any value less than or equal to maxChannelCount. An IndexSizeError exception MUST be thrown if this value is not within the valid range. Giving a concrete example, if the audio hardware supports 8-channel output, then we may set channelCount to 8, and render 8 channels of output.

For an OfflineAudioContext, the defaults are

where numberOfChannels is the number of channels specified when constructing the OfflineAudioContext. This value may not be changed; a NotSupportedError exception MUST be thrown if channelCount is changed to a different value.

[Exposed=Window]
interface AudioDestinationNode : AudioNode {
    readonly attribute unsigned long maxChannelCount;
};

maxChannelCount, of type unsigned long, readonly

The maximum number of channels that the channelCount attribute can be set to. An AudioDestinationNode representing the audio hardware end-point (the normal case) can potentially output more than 2 channels of audio if the audio hardware is multi-channel. maxChannelCount is the maximum number of channels that this hardware is capable of supporting.

This interface represents the position and orientation of the person listening to the audio scene. All PannerNode objects spatialize in relation to the BaseAudioContext’s listener. See § 6 Spatialization/Panning for more details about spatialization.

The positionX, positionY, and positionZ parameters represent the location of the listener in 3D Cartesian coordinate space. PannerNode objects use this position relative to individual audio sources for spatialization.

The forwardX, forwardY, and forwardZ parameters represent a direction vector in 3D space. Both a forward vector and an up vector are used to determine the orientation of the listener. In simple human terms, the forward vector represents which direction the person’s nose is pointing. The up vector represents the direction the top of a person’s head is pointing. These two vectors are expected to be linearly independent. For normative requirements of how these values are to be interpreted, see the § 6 Spatialization/Panning section.

[Exposed=Window]
interface AudioListener {
    readonly attribute AudioParam positionX;
    readonly attribute AudioParam positionY;
    readonly attribute AudioParam positionZ;
    readonly attribute AudioParam forwardX;
    readonly attribute AudioParam forwardY;
    readonly attribute AudioParam forwardZ;
    readonly attribute AudioParam upX;
    readonly attribute AudioParam upY;
    readonly attribute AudioParam upZ;
    undefined setPosition (float x, float y, float z);
    undefined setOrientation (float x, float y, float z, float xUp, float yUp, float zUp);
};

forwardX, of type AudioParam, readonly

Sets the x coordinate component of the forward direction the listener is pointing in 3D Cartesian coordinate space.

forwardY, of type AudioParam, readonly

Sets the y coordinate component of the forward direction the listener is pointing in 3D Cartesian coordinate space.

forwardZ, of type AudioParam, readonly

Sets the z coordinate component of the forward direction the listener is pointing in 3D Cartesian coordinate space.

positionX, of type AudioParam, readonly

Sets the x coordinate position of the audio listener in a 3D Cartesian coordinate space.

positionY, of type AudioParam, readonly

Sets the y coordinate position of the audio listener in a 3D Cartesian coordinate space.

positionZ, of type AudioParam, readonly

Sets the z coordinate position of the audio listener in a 3D Cartesian coordinate space.

upX, of type AudioParam, readonly

Sets the x coordinate component of the up direction the listener is pointing in 3D Cartesian coordinate space.

upY, of type AudioParam, readonly

Sets the y coordinate component of the up direction the listener is pointing in 3D Cartesian coordinate space.

upZ, of type AudioParam, readonly

Sets the z coordinate component of the up direction the listener is pointing in 3D Cartesian coordinate space.

setOrientation(x, y, z, xUp, yUp, zUp)

This method is DEPRECATED. It is equivalent to setting forwardX.value, forwardY.value, forwardZ.value, upX.value, upY.value, and upZ.value directly with the given x, y, z, xUp, yUp, and zUp values, respectively.

Consequently, if any of the forwardX, forwardY, forwardZ, upX, upY and upZ AudioParams have an automation curve set using setValueCurveAtTime() at the time this method is called, a NotSupportedError MUST be thrown.

setOrientation() describes which direction the listener is pointing in the 3D cartesian coordinate space. Both a forward vector and an up vector are provided. In simple human terms, the forward vector represents which direction the person’s nose is pointing. The up vector represents the direction the top of a person’s head is pointing. These two vectors are expected to be linearly independent. For normative requirements of how these values are to be interpreted, see the § 6 Spatialization/Panning.

The x, y, and z parameters represent a forward direction vector in 3D space, with the default value being (0,0,-1).

The xUp, yUp, and zUp parameters represent an up direction vector in 3D space, with the default value being (0,1,0).

setPosition(x, y, z)

This method is DEPRECATED. It is equivalent to setting positionX.value, positionY.value, and positionZ.value directly with the given x, y, and z values, respectively.

Consequently, any of the positionX, positionY, and positionZ AudioParams for this AudioListener have an automation curve set using setValueCurveAtTime() at the time this method is called, a NotSupportedError MUST be thrown.

setPosition() sets the position of the listener in a 3D cartesian coordinate space. PannerNode objects use this position relative to individual audio sources for spatialization.

The x, y, and z parameters represent the coordinates in 3D space.

The default value is (0,0,0).

Because AudioListener’s parameters can be connected with AudioNodes and they can also affect the output of PannerNodes in the same graph, the node ordering algorithm should take the AudioListener into consideration when computing the order of processing. For this reason, all the PannerNodes in the graph have the AudioListener as input.

This is an Event object which is dispatched to ScriptProcessorNode nodes. It will be removed when the ScriptProcessorNode is removed, as the replacement AudioWorkletNode uses a different approach.

The event handler processes audio from the input (if any) by accessing the audio data from the inputBuffer attribute. The audio data which is the result of the processing (or the synthesized data if there are no inputs) is then placed into the outputBuffer.

[Exposed=Window]
interface AudioProcessingEvent : Event {
    constructor (DOMString type, AudioProcessingEventInit eventInitDict);
    readonly attribute double playbackTime;
    readonly attribute AudioBuffer inputBuffer;
    readonly attribute AudioBuffer outputBuffer;
};

inputBuffer, of type AudioBuffer, readonly

An AudioBuffer containing the input audio data. It will have a number of channels equal to the numberOfInputChannels parameter of the createScriptProcessor() method. This AudioBuffer is only valid while in the scope of the audioprocess event handler functions. Its values will be meaningless outside of this scope.

outputBuffer, of type AudioBuffer, readonly

An AudioBuffer where the output audio data MUST be written. It will have a number of channels equal to the numberOfOutputChannels parameter of the createScriptProcessor() method. Script code within the scope of the audioprocess event handler functions are expected to modify the Float32Array arrays representing channel data in this AudioBuffer. Any script modifications to this AudioBuffer outside of this scope will not produce any audible effects.

playbackTime, of type double, readonly

The time when the audio will be played in the same time coordinate system as the AudioContext’s currentTime.

dictionary AudioProcessingEventInit : EventInit {
    required double playbackTime;
    required AudioBuffer inputBuffer;
    required AudioBuffer outputBuffer;
};

inputBuffer, of type AudioBuffer

Value to be assigned to the inputBuffer attribute of the event.

outputBuffer, of type AudioBuffer

Value to be assigned to the outputBuffer attribute of the event.

playbackTime, of type double

Value to be assigned to the playbackTime attribute of the event.

BiquadFilterNode is an AudioNode processor implementing very common low-order 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. The filter parameters such as frequency can be changed over time for filter sweeps, etc. Each BiquadFilterNode can be configured as one of a number of common filter types as shown in the IDL below. The default filter type is "lowpass".

Both frequency and detune form a compound parameter and are both a-rate. They are used together to determine a computedFrequency value:

computedFrequency(t) = frequency(t) * pow(2, detune(t) / 1200)

The nominal range for this compound parameter is [0, Nyquist frequency].

The number of channels of the output always equals the number of channels of the input.

enum BiquadFilterType {
    "lowpass",
    "highpass",
    "bandpass",
    "lowshelf",
    "highshelf",
    "peaking",
    "notch",
    "allpass"
};

frequency

The cutoff frequency

Q

Controls how peaked the response will be at the cutoff frequency. A large value makes the response more peaked.

gain

Not used in this filter type

frequency

The cutoff frequency below which the frequencies are attenuated

Q

Controls how peaked the response will be at the cutoff frequency. A large value makes the response more peaked.

gain

Not used in this filter type

frequency

The center of the frequency band

Q

Controls the width of the band. The width becomes narrower as the Q value increases.

gain

Not used in this filter type

frequency

The upper limit of the frequences where the boost (or attenuation) is applied.

Q

Not used in this filter type.

gain

The boost, in dB, to be applied. If the value is negative, the frequencies are attenuated.

frequency

The lower limit of the frequences where the boost (or attenuation) is applied.

Q

Not used in this filter type.

gain

The boost, in dB, to be applied. If the value is negative, the frequencies are attenuated.

frequency

The center frequency of where the boost is applied.

Q

Controls the width of the band of frequencies that are boosted. A large value implies a narrow width.

gain

The boost, in dB, to be applied. If the value is negative, the frequencies are attenuated.

frequency

The center frequency of where the notch is applied.

Q

Controls the width of the band of frequencies that are attenuated. A large value implies a narrow width.

gain

Not used in this filter type.

frequency

The frequency where the center of the phase transition occurs. Viewed another way, this is the frequency with maximal group delay.

Q

Controls how sharp the phase transition is at the center frequency. A larger value implies a sharper transition and a larger group delay.

gain

Not used in this filter type.

All attributes of the BiquadFilterNode are a-rate AudioParams.

[Exposed=Window]
interface BiquadFilterNode : AudioNode {
    constructor (BaseAudioContext context, optional BiquadFilterOptions options = {});
    attribute BiquadFilterType type;
    readonly attribute AudioParam frequency;
    readonly attribute AudioParam detune;
    readonly attribute AudioParam Q;
    readonly attribute AudioParam gain;
    undefined getFrequencyResponse (Float32Array frequencyHz,
                                    Float32Array magResponse,
                                    Float32Array phaseResponse);
};

BiquadFilterNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

Q, of type AudioParam, readonly

The Q factor of the filter.

For lowpass and highpass filters the Q value is interpreted to be in dB. For these filters the nominal range is \([-Q_{lim}, Q_{lim}]\) where \(Q_{lim}\) is the largest value for which \(10^{Q/20}\) does not overflow. This is approximately \(770.63678\).

For the bandpass, notch, allpass, and peaking filters, this value is a linear value. The value is related to the bandwidth of the filter and hence should be a positive value. The nominal range is \([0, 3.4028235e38]\), the upper limit being the most-positive-single-float.

This is not used for the lowshelf and highshelf filters.

detune, of type AudioParam, readonly

A detune value, in cents, for the frequency. It forms a compound parameter with frequency to form the computedFrequency.

frequency, of type AudioParam, readonly

The frequency at which the BiquadFilterNode will operate, in Hz. It forms a compound parameter with detune to form the computedFrequency.

gain, of type AudioParam, readonly

The gain of the filter. Its value is in dB units. The gain is only used for lowshelf, highshelf, and peaking filters.

type, of type BiquadFilterType

The type of this BiquadFilterNode. Its default value is "lowpass". The exact meaning of the other parameters depend on the value of the type attribute.

getFrequencyResponse(frequencyHz, magResponse, phaseResponse)

Given the [[current value]] from each of the filter parameters, synchronously calculates the frequency response for the specified frequencies. The three parameters MUST be Float32Arrays of the same length, or an InvalidAccessError MUST be thrown.

The frequency response returned MUST be computed with the AudioParam sampled for the current processing block.

Arguments for the BiquadFilterNode.getFrequencyResponse() method. Parameter Type Nullable Optional Description frequencyHz Float32Array ✘ ✘ This parameter specifies an array of frequencies, in Hz, at which the response values will be calculated. magResponse Float32Array ✘ ✘ This parameter specifies an output array receiving the linear magnitude response values. If a value in the frequencyHz parameter is not within [0, sampleRate/2], where sampleRate is the value of the sampleRate property of the AudioContext, the corresponding value at the same index of the magResponse array MUST be NaN. phaseResponse Float32Array ✘ ✘ This parameter specifies an output array receiving the phase response values in radians. If a value in the frequencyHz parameter is not within [0; sampleRate/2], where sampleRate is the value of the sampleRate property of the AudioContext, the corresponding value at the same index of the phaseResponse array MUST be NaN.

This specifies the options to be used when constructing a BiquadFilterNode. All members are optional; if not specified, the normal default values are used to construct the node.

dictionary BiquadFilterOptions : AudioNodeOptions {
    BiquadFilterType type = "lowpass";
    float Q = 1;
    float detune = 0;
    float frequency = 350;
    float gain = 0;
};

Q, of type float, defaulting to 1

The desired initial value for Q.

detune, of type float, defaulting to 0

The desired initial value for detune.

frequency, of type float, defaulting to 350

The desired initial value for frequency.

gain, of type float, defaulting to 0

The desired initial value for gain.

type, of type BiquadFilterType, defaulting to "lowpass"

The desired initial type of the filter.

There are multiple ways of implementing the type of filters available through the BiquadFilterNode each having very different characteristics. The formulas in this section describe the filters that a conforming implementation MUST implement, as they determine the characteristics of the different filter types. They are inspired by formulas found in the Audio EQ Cookbook.

The BiquadFilterNode processes audio with a transfer function of

$$
 H(z) = \frac{\frac{b_0}{a_0} + \frac{b_1}{a_0}z^{-1} + \frac{b_2}{a_0}z^{-2}}
                                          {1+\frac{a_1}{a_0}z^{-1}+\frac{a_2}{a_0}z^{-2}}
$$

which is equivalent to a time-domain equation of:

$$
a_0 y(n) + a_1 y(n-1) + a_2 y(n-2) =
    b_0 x(n) + b_1 x(n-1) + b_2 x(n-2)
$$

The initial filter state is 0.

Note: While fixed filters are stable, it is possible to create unstable biquad filters using automations of AudioParams. It is the developers responsibility to manage this.

Note: The UA may produce a warning to notify the user that NaN values have occurred in the filter state. This is usually indicative of an unstable filter.

The coefficients in the transfer function above are different for each node type. The following intermediate variables are necessary for their computation, based on the computedValue of the AudioParams of the BiquadFilterNode.

• Let \(F_s\) be the value of the sampleRate attribute for this AudioContext.

• Let \(f_0\) be the value of the computedFrequency.

• Let \(G\) be the value of the gain AudioParam.

• Let \(Q\) be the value of the Q AudioParam.

• Finally let

  $$
  \begin{align*}
      A &= 10^{\frac{G}{40}} \\
      \omega_0 &= 2\pi\frac{f_0}{F_s} \\
      \alpha_Q &= \frac{\sin\omega_0}{2Q} \\
      \alpha_{Q_{dB}} &= \frac{\sin\omega_0}{2 \cdot 10^{Q/20}} \\
      S &= 1 \\
      \alpha_S &= \frac{\sin\omega_0}{2}\sqrt{\left(A+\frac{1}{A}\right)\left(\frac{1}{S}-1\right)+2}
  \end{align*}
  $$
  

The six coefficients (\(b_0, b_1, b_2, a_0, a_1, a_2\)) for each filter type, are:

"lowpass"

$$
    \begin{align*}
        b_0 &= \frac{1 - \cos\omega_0}{2} \\
        b_1 &= 1 - \cos\omega_0 \\
        b_2 &= \frac{1 - \cos\omega_0}{2} \\
        a_0 &= 1 + \alpha_{Q_{dB}} \\
        a_1 &= -2 \cos\omega_0 \\
        a_2 &= 1 - \alpha_{Q_{dB}}
    \end{align*}
$$

"highpass"

$$
    \begin{align*}
        b_0 &= \frac{1 + \cos\omega_0}{2} \\
        b_1 &= -(1 + \cos\omega_0) \\
        b_2 &= \frac{1 + \cos\omega_0}{2} \\
        a_0 &= 1 + \alpha_{Q_{dB}} \\
        a_1 &= -2 \cos\omega_0 \\
        a_2 &= 1 - \alpha_{Q_{dB}}
    \end{align*}
$$

"bandpass"

$$
    \begin{align*}
        b_0 &= \alpha_Q \\
        b_1 &= 0 \\
        b_2 &= -\alpha_Q \\
        a_0 &= 1 + \alpha_Q \\
        a_1 &= -2 \cos\omega_0 \\
        a_2 &= 1 - \alpha_Q
    \end{align*}
$$

"notch"

$$
    \begin{align*}
        b_0 &= 1 \\
        b_1 &= -2\cos\omega_0 \\
        b_2 &= 1 \\
        a_0 &= 1 + \alpha_Q \\
        a_1 &= -2 \cos\omega_0 \\
        a_2 &= 1 - \alpha_Q
    \end{align*}
$$

"allpass"

$$
    \begin{align*}
        b_0 &= 1 - \alpha_Q \\
        b_1 &= -2\cos\omega_0 \\
        b_2 &= 1 + \alpha_Q \\
        a_0 &= 1 + \alpha_Q \\
        a_1 &= -2 \cos\omega_0 \\
        a_2 &= 1 - \alpha_Q
    \end{align*}
$$

"peaking"

$$
    \begin{align*}
        b_0 &= 1 + \alpha_Q\, A \\
        b_1 &= -2\cos\omega_0 \\
        b_2 &= 1 - \alpha_Q\,A \\
        a_0 &= 1 + \frac{\alpha_Q}{A} \\
        a_1 &= -2 \cos\omega_0 \\
        a_2 &= 1 - \frac{\alpha_Q}{A}
    \end{align*}
$$

"lowshelf"

$$
    \begin{align*}
        b_0 &= A \left[ (A+1) - (A-1) \cos\omega_0 + 2 \alpha_S \sqrt{A})\right] \\
        b_1 &= 2 A \left[ (A-1) - (A+1) \cos\omega_0 )\right] \\
        b_2 &= A \left[ (A+1) - (A-1) \cos\omega_0 - 2 \alpha_S \sqrt{A}) \right] \\
        a_0 &= (A+1) + (A-1) \cos\omega_0 + 2 \alpha_S \sqrt{A} \\
        a_1 &= -2 \left[ (A-1) + (A+1) \cos\omega_0\right] \\
        a_2 &= (A+1) + (A-1) \cos\omega_0 - 2 \alpha_S \sqrt{A})
    \end{align*}
$$

"highshelf"

$$
    \begin{align*}
        b_0 &= A\left[ (A+1) + (A-1)\cos\omega_0 + 2\alpha_S\sqrt{A} )\right] \\
        b_1 &= -2A\left[ (A-1) + (A+1)\cos\omega_0 )\right] \\
        b_2 &= A\left[ (A+1) + (A-1)\cos\omega_0 - 2\alpha_S\sqrt{A} )\right] \\
        a_0 &= (A+1) - (A-1)\cos\omega_0 + 2\alpha_S\sqrt{A} \\
        a_1 &= 2\left[ (A-1) - (A+1)\cos\omega_0\right] \\
        a_2 &= (A+1) - (A-1)\cos\omega_0 - 2\alpha_S\sqrt{A}
    \end{align*}
$$

The ChannelMergerNode is for use in more advanced applications and would often be used in conjunction with ChannelSplitterNode.

This interface represents an AudioNode for combining channels from multiple audio streams into a single audio stream. It has a variable number of inputs (defaulting to 6), but not all of them need be connected. There is a single output whose audio stream has a number of channels equal to the number of inputs when any of the inputs is actively processing. If none of the inputs are actively processing, then output is a single channel of silence.

To merge multiple inputs into one stream, each input gets downmixed into one channel (mono) based on the specified mixing rule. An unconnected input still counts as one silent channel in the output. Changing input streams does not affect the order of output channels.

For example, if a default

has two connected stereo inputs, the first and second input will be downmixed to mono respectively before merging. The output will be a 6-channel stream whose first two channels are be filled with the first two (downmixed) inputs and the rest of channels will be silent.

Also the ChannelMergerNode can be used to arrange multiple audio streams in a certain order for the multi-channel speaker array such as 5.1 surround set up. The merger does not interpret the channel identities (such as left, right, etc.), but simply combines channels in the order that they are input.

[Exposed=Window]
interface ChannelMergerNode : AudioNode {
    constructor (BaseAudioContext context, optional ChannelMergerOptions options = {});
};

ChannelMergerNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

dictionary ChannelMergerOptions : AudioNodeOptions {
    unsigned long numberOfInputs = 6;
};

numberOfInputs, of type unsigned long, defaulting to 6

The number inputs for the ChannelMergerNode. See createChannelMerger() for constraints on this value.

The ChannelSplitterNode is for use in more advanced applications and would often be used in conjunction with ChannelMergerNode.

This interface represents an AudioNode for accessing the individual channels of an audio stream in the routing graph. It has a single input, and a number of "active" outputs which equals the number of channels in the input audio stream. For example, if a stereo input is connected to an ChannelSplitterNode then the number of active outputs will be two (one from the left channel and one from the right). There are always a total number of N outputs (determined by the numberOfOutputs parameter to the AudioContext method createChannelSplitter()), The default number is 6 if this value is not provided. Any outputs which are not "active" will output silence and would typically not be connected to anything.

Please note that in this example, the splitter does not interpret the channel identities (such as left, right, etc.), but simply splits out channels in the order that they are input.

One application for ChannelSplitterNode is for doing "matrix mixing" where individual gain control of each channel is desired.

[Exposed=Window]
interface ChannelSplitterNode : AudioNode {
    constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {});
};

ChannelSplitterNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

dictionary ChannelSplitterOptions : AudioNodeOptions {
    unsigned long numberOfOutputs = 6;
};

numberOfOutputs, of type unsigned long, defaulting to 6

The number outputs for the ChannelSplitterNode. See createChannelSplitter() for constraints on this value.

This interface represents a constant audio source whose output is nominally a constant value. It is useful as a constant source node in general and can be used as if it were a constructible AudioParam by automating its offset or connecting another node to it.

The single output of this node consists of one channel (mono).

[Exposed=Window]
interface ConstantSourceNode : AudioScheduledSourceNode {
    constructor (BaseAudioContext context, optional ConstantSourceOptions options = {});
    readonly attribute AudioParam offset;
};

ConstantSourceNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

offset, of type AudioParam, readonly

The constant value of the source.

This specifies options for constructing a ConstantSourceNode. All members are optional; if not specified, the normal defaults are used for constructing the node.

dictionary ConstantSourceOptions {
    float offset = 1;
};

offset, of type float, defaulting to 1

The initial value for the offset AudioParam of this node.

This interface represents a processing node which applies a linear convolution effect given an impulse response.

The input of this node is either mono (1 channel) or stereo (2 channels) and cannot be increased. Connections from nodes with more channels will be down-mixed appropriately.

There are channelCount constraints and channelCountMode constraints for this node. These constraints ensure that the input to the node is either mono or stereo.

[Exposed=Window]
interface ConvolverNode : AudioNode {
    constructor (BaseAudioContext context, optional ConvolverOptions options = {});
    attribute AudioBuffer? buffer;
    attribute boolean normalize;
};

ConvolverNode(context, options)

When the constructor is called with a BaseAudioContext context and an option object options, execute these steps:

1. Set the attributes normalize to the inverse of the value of disableNormalization.

2. If buffer exists, set the buffer attribute to its value.

   Note: This means that the buffer will be normalized according to the value of the normalize attribute.

3. Let o be new AudioNodeOptions dictionary.

4. If channelCount exists in options, set channelCount on o with the same value.

5. If channelCountMode exists in options, set channelCountMode on o with the same value.

6. If channelInterpretation exists in options, set channelInterpretation on o with the same value.

7. Initialize the AudioNode this, with c and o as argument.

buffer, of type AudioBuffer, nullable

At the time when this attribute is set, the buffer and the state of the normalize attribute will be used to configure the ConvolverNode with this impulse response having the given normalization. The initial value of this attribute is null.

Note: If the buffer is set to an new buffer, audio may glitch. If this is undesirable, it is recommended to create a new ConvolverNode to replace the old, possibly cross-fading between the two.

Note: The ConvolverNode produces a mono output only in the single case where there is a single input channel and a single-channel buffer. In all other cases, the output is stereo. In particular, when the buffer has four channels and there are two input channels, the ConvolverNode performs matrix "true" stereo convolution. For normative information please see the channel configuration diagrams

normalize, of type boolean

Controls whether the impulse response from the buffer will be scaled by an equal-power normalization when the buffer attribute is set. Its default value is true in order to achieve a more uniform output level from the convolver when loaded with diverse impulse responses. If normalize is set to false, then the convolution will be rendered with no pre-processing/scaling of the impulse response. Changes to this value do not take effect until the next time the buffer attribute is set.

If the normalize attribute is false when the buffer attribute is set then the ConvolverNode will perform a linear convolution given the exact impulse response contained within the buffer.

Otherwise, if the normalize attribute is true when the buffer attribute is set then the ConvolverNode will first perform a scaled RMS-power analysis of the audio data contained within buffer to calculate a normalizationScale given this algorithm:

function calculateNormalizationScale(buffer) {    const GainCalibration = 0.00125;    const GainCalibrationSampleRate = 44100;    const MinPower = 0.000125;    // Normalize by RMS power.    const numberOfChannels = buffer.numberOfChannels;    const length = buffer.length;    let power = 0;    for (let i = 0; i < numberOfChannels; i++) {        let channelPower = 0;        const channelData = buffer.getChannelData(i);        for (let j = 0; j < length; j++) {            const sample = channelData[j];            channelPower += sample * sample;        }        power += channelPower;    }    power = Math.sqrt(power / (numberOfChannels * length));    // Protect against accidental overload.    if (!isFinite(power) || isNaN(power) || power < MinPower)        power = MinPower;    let scale = 1 / power;    // Calibrate to make perceived volume same as unprocessed.    scale *= GainCalibration;    // Scale depends on sample-rate.    if (buffer.sampleRate)        scale *= GainCalibrationSampleRate / buffer.sampleRate;    // True-stereo compensation.    if (numberOfChannels == 4)        scale *= 0.5;    return scale;}

During processing, the ConvolverNode will then take this calculated normalizationScale value and multiply it by the result of the linear convolution resulting from processing the input with the impulse response (represented by the buffer) to produce the final output. Or any mathematically equivalent operation may be used, such as pre-multiplying the input by normalizationScale, or pre-multiplying a version of the impulse-response by normalizationScale.

The specifies options for constructing a ConvolverNode. All members are optional; if not specified, the node is contructing using the normal defaults.

dictionary ConvolverOptions : AudioNodeOptions {
    AudioBuffer? buffer;
    boolean disableNormalization = false;
};

buffer, of type AudioBuffer, nullable

The desired buffer for the ConvolverNode. This buffer will be normalized according to the value of disableNormalization.

disableNormalization, of type boolean, defaulting to false

The opposite of the desired initial value for the normalize attribute of the ConvolverNode.

Implementations MUST support the following allowable configurations of impulse response channels in a ConvolverNode to achieve various reverb effects with 1 or 2 channels of input.

As shown in the diagram below, single channel convolution operates on a mono audio input, using a mono impulse response, and generating a mono output. The remaining images in the diagram illustrate the supported cases for mono and stereo playback where the number of channels of the input is 1 or 2, and the number of channels in the buffer is 1, 2, or 4. Developers desiring more complex and arbitrary matrixing can use a ChannelSplitterNode, multiple single-channel ConvolverNodes and a ChannelMergerNode.

If this node is not actively processing, the output is a single channel of silence.

Note: The diagrams below show the outputs when actively processing.

A delay-line is a fundamental building block in audio applications. This interface is an AudioNode with a single input and single output.

The number of channels of the output always equals the number of channels of the input.

It delays the incoming audio signal by a certain amount. Specifically, at each time t, input signal input(t), delay time delayTime(t) and output signal output(t), the output will be output(t) = input(t - delayTime(t)). The default delayTime is 0 seconds (no delay).

When the number of channels in a DelayNode’s input changes (thus changing the output channel count also), there may be delayed audio samples which have not yet been output by the node and are part of its internal state. If these samples were received earlier with a different channel count, they MUST be upmixed or downmixed before being combined with newly received input so that all internal delay-line mixing takes place using the single prevailing channel layout.

Note: By definition, a DelayNode introduces an audio processing latency equal to the amount of the delay.

[Exposed=Window]
interface DelayNode : AudioNode {
    constructor (BaseAudioContext context, optional DelayOptions options = {});
    readonly attribute AudioParam delayTime;
};

DelayNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

delayTime, of type AudioParam, readonly

An AudioParam object representing the amount of delay (in seconds) to apply. Its default value is 0 (no delay). The minimum value is 0 and the maximum value is determined by the maxDelayTime argument to the AudioContext method createDelay() or the maxDelayTime member of the DelayOptions dictionary for the constructor.

If DelayNode is part of a cycle, then the value of the delayTime attribute is clamped to a minimum of one render quantum.

This specifies options for constructing a DelayNode. All members are optional; if not given, the node is constructed using the normal defaults.

dictionary DelayOptions : AudioNodeOptions {
    double maxDelayTime = 1;
    double delayTime = 0;
};

delayTime, of type double, defaulting to 0

The initial delay time for the node.

maxDelayTime, of type double, defaulting to 1

The maximum delay time for the node. See createDelay(maxDelayTime) for constraints.

A DelayNode has an internal buffer that holds delayTime seconds of audio.

The processing of a DelayNode is broken down in two parts: writing to the delay line, and reading from the delay line. This is done via two internal AudioNodes (that are not available to authors and exist only to ease the description of the inner workings of the node). Both are created from a DelayNode.

Creating a DelayWriter for a DelayNode means creating an object that has the same interface as an AudioNode, and that writes the input audio into the internal buffer of the DelayNode. It has the same input connections as the DelayNode it was created from.

Creating a DelayReader for a DelayNode means creating an object that has the same interface as an AudioNode, and that can read the audio data from the internal buffer of the DelayNode. It is connected to the same AudioNodes as the DelayNode it was created from. A DelayReader is a source node.

When processing an input buffer, a DelayWriter MUST write the audio to the internal buffer of the DelayNode.

When producing an output buffer, a DelayReader MUST yield exactly the audio that was written to the corresponding DelayWriter delayTime seconds ago.

Note: This means that channel count changes are reflected after the delay time has passed.

DynamicsCompressorNode is an AudioNode processor implementing a dynamics compression effect.

Dynamics compression is very commonly used in musical production and game audio. It lowers the volume of the loudest parts of the signal and raises the volume of the softest parts. Overall, a louder, richer, and fuller sound can be achieved. It is especially important in games and musical applications where large numbers of individual sounds are played simultaneous to control the overall signal level and help avoid clipping (distorting) the audio output to the speakers.

[Exposed=Window]
interface DynamicsCompressorNode : AudioNode {
    constructor (BaseAudioContext context,
                 optional DynamicsCompressorOptions options = {});
    readonly attribute AudioParam threshold;
    readonly attribute AudioParam knee;
    readonly attribute AudioParam ratio;
    readonly attribute float reduction;
    readonly attribute AudioParam attack;
    readonly attribute AudioParam release;
};

DynamicsCompressorNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

Let [[internal reduction]] be a private slot on this, that holds a floating point number, in decibels. Set [[internal reduction]] to 0.0.

attack, of type AudioParam, readonly

The amount of time (in seconds) to reduce the gain by 10dB.

knee, of type AudioParam, readonly

A decibel value representing the range above the threshold where the curve smoothly transitions to the "ratio" portion.

ratio, of type AudioParam, readonly

The amount of dB change in input for a 1 dB change in output.

reduction, of type float, readonly

A read-only decibel value for metering purposes, representing the current amount of gain reduction that the compressor is applying to the signal. If fed no signal the value will be 0 (no gain reduction). When this attribute is read, return the value of the private slot [[internal reduction]].

release, of type AudioParam, readonly

The amount of time (in seconds) to increase the gain by 10dB.

threshold, of type AudioParam, readonly

The decibel value above which the compression will start taking effect.

This specifies the options to use in constructing a DynamicsCompressorNode. All members are optional; if not specified the normal defaults are used in constructing the node.

dictionary DynamicsCompressorOptions : AudioNodeOptions {
    float attack = 0.003;
    float knee = 30;
    float ratio = 12;
    float release = 0.25;
    float threshold = -24;
};

attack, of type float, defaulting to 0.003

The initial value for the attack AudioParam.

knee, of type float, defaulting to 30

The initial value for the knee AudioParam.

ratio, of type float, defaulting to 12

The initial value for the ratio AudioParam.

release, of type float, defaulting to 0.25

The initial value for the release AudioParam.

threshold, of type float, defaulting to -24

The initial value for the threshold AudioParam.

Dynamics compression can be implemented in a variety of ways. The DynamicsCompressorNode implements a dynamics processor that has the following characteristics:

• Fixed look-ahead (this means that an DynamicsCompressorNode adds a fixed latency to the signal chain).

• Configurable attack speed, release speed, threshold, knee hardness and ratio.

• Side-chaining is not supported.

• The gain reduction is reported via the reduction property on the DynamicsCompressorNode.

• The compression curve has three parts:

  • The first part is the identity: \(f(x) = x\).

  • The second part is the soft-knee portion, which MUST be a monotonically increasing function.

  • The third part is a linear function: \(f(x) = \frac{1}{ratio} \cdot x \).

  This curve MUST be continuous and piece-wise differentiable, and corresponds to a target output level, based on the input level.

Graphically, such a curve would look something like this:

Internally, the DynamicsCompressorNode is described with a combination of other AudioNodes, as well as a special algorithm, to compute the gain reduction value.

The following AudioNode graph is used internally, input and output respectively being the input and output AudioNode, context the BaseAudioContext for this DynamicsCompressorNode, and a new class, EnvelopeFollower, that instantiates a special object that behaves like an AudioNode, described below:

const delay = new DelayNode(context, {delayTime: 0.006});
const gain = new GainNode(context);
const compression = new EnvelopeFollower();

input.connect(delay).connect(gain).connect(output);
input.connect(compression).connect(gain.gain);

Note: This implements the pre-delay and the application of the reduction gain.

The following algorithm describes the processing performed by an EnvelopeFollower object, to be applied to the input signal to produce the gain reduction value. An EnvelopeFollower has two slots holding floating point values. Those values persist accros invocation of this algorithm.

• Let [[detector average]] be a floating point number, initialized to 0.0.

• Let [[compressor gain]] be a floating point number, initialized to 1.0.

The following algorithm allow determining a value for

, for each sample of input, for a render quantum of audio.

1. Let attack and release have the values of attack and release, respectively, sampled at the time of processing (those are k-rate parameters), mutiplied by the sample-rate of the BaseAudioContext this DynamicsCompressorNode is associated with.

2. Let detector average be the value of the slot [[detector average]].

3. Let compressor gain be the value of the slot [[compressor gain]].

4. For each sample input of the render quantum to be processed, execute the following steps:

   1. If the absolute value of input is less than 0.0001, let attenuation be 1.0. Else, let shaped input be the value of applying the compression curve to the absolute value of input. Let attenuation be shaped input divided by the absolute value of input.

   2. Let releasing be true if attenuation is greater than compressor gain, false otherwise.

   3. Let detector rate be the result of applying the detector curve to attenuation.

   4. Subtract detector average from attenuation, and multiply the result by detector rate. Add this new result to detector average.

   5. Clamp detector average to a maximum of 1.0.

   6. Let envelope rate be the result of computing the envelope rate based on values of attack and release.

   7. If releasing is true, set compressor gain to be the product of compressor gain and envelope rate, clamped to a maximum of 1.0.

   8. Else, if releasing is false, let gain increment to be detector average minus compressor gain. Multiply gain increment by envelope rate, and add the result to compressor gain.

   9. Compute reduction gain to be compressor gain multiplied by the return value of computing the makeup gain.

   10. Compute metering gain to be reduction gain, converted to decibel.

5. Set [[compressor gain]] to compressor gain.

6. Set [[detector average]] to detector average.

7. Atomically set the internal slot [[internal reduction]] to the value of metering gain.

   Note: This step makes the metering gain update once per block, at the end of the block processing.

The makeup gain is a fixed gain stage that only depends on ratio, knee and threshold parameter of the compressor, and not on the input signal. The intent here is to increase the output level of the compressor so it is comparable to the input level.

means executing the following steps:

1. Let full range gain be the value returned by applying the compression curve to the value 1.0.

2. Let full range makeup gain be the inverse of full range gain.

3. Return the result of taking the 0.6 power of full range makeup gain.

is done by applying a function to the ratio of the

and the

. User-agents are allowed to choose the shape of the envelope function. However, this function MUST respect the following constraints:

• The envelope rate MUST be the calculated from the ratio of the compressor gain and the detector average.

  Note: When attacking, this number less than or equal to 1, when releasing, this number is strictly greater than 1.

• The attack curve MUST be a continuous, monotonically increasing function in the range \([0, 1]\). The shape of this curve MAY be controlled by attack.

• The release curve MUST be a continuous, monotonically decreasing function that is always greater than 1. The shape of this curve MAY be controlled by release.

This operation returns the value computed by applying this function to the ratio of compressor gain and detector average.

Applying the detector curve to the change rate when attacking or releasing allow implementing adaptive release. It is a function that MUST respect the following constraints:

• The output of the function MUST be in \([0,1]\).

• The function MUST be monotonically increasing, continuous.

Note: It is allowed, for example, to have a compressor that performs an adaptive release, that is, releasing faster the harder the compression, or to have curves for attack and release that are not of the same shape.

Applying a

to a value means computing the value of this sample when passed to a function, and returning the computed value. This function MUST respect the following characteristics:

1. Let threshold and knee have the values of threshold and knee, respectively, converted to linear units and sampled at the time of processing of this block (as k-rate parameters).

2. Calculate the sum of threshold plus knee also sampled at the time of processing of this block (as k-rate parameters).

3. Let knee end threshold have the value of this sum converted to linear units.

4. Let ratio have the value of the ratio, sampled at the time of processing of this block (as a k-rate parameter).

5. This function is the identity up to the value of the linear threshold (i.e., \(f(x) = x\)).

6. From the threshold up to the knee end threshold, User-Agents can choose the curve shape. The whole function MUST be monotonically increasing and continuous.

   Note: If the knee is 0, the DynamicsCompressorNode is called a hard-knee compressor.

7. This function is linear, based on the ratio, after the threshold and the soft knee (i.e., \(f(x) = \frac{1}{ratio} \cdot x \)).

Converting a value \(v\) in

means executing the following steps:

1. If \(v\) is equal to zero, return -1000.

2. Else, return \( 20 \, \log_{10}{v} \).

Converting a value \(v\) in decibels to linear gain unit means returning \(10^{v/20}\).

Changing the gain of an audio signal is a fundamental operation in audio applications. This interface is an AudioNode with a single input and single output:

Each sample of each channel of the input data of the GainNode MUST be multiplied by the computedValue of the gain AudioParam.

[Exposed=Window]
interface GainNode : AudioNode {
    constructor (BaseAudioContext context, optional GainOptions options = {});
    readonly attribute AudioParam gain;
};

GainNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

gain, of type AudioParam, readonly

Represents the amount of gain to apply.

This specifies options to use in constructing a GainNode. All members are optional; if not specified, the normal defaults are used in constructing the node.

dictionary GainOptions : AudioNodeOptions {
    float gain = 1.0;
};

gain, of type float, defaulting to 1.0

The initial gain value for the gain AudioParam.

IIRFilterNode is an AudioNode processor implementing a general IIR Filter. In general, it is best to use BiquadFilterNode’s to implement higher-order filters 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, so if such filters are needed or automation is not needed, then IIR filters may be appropriate.

Once created, the coefficients of the IIR filter cannot be changed.

The number of channels of the output always equals the number of channels of the input.

[Exposed=Window]
interface IIRFilterNode : AudioNode {
    constructor (BaseAudioContext context, IIRFilterOptions options);
    undefined getFrequencyResponse (Float32Array frequencyHz,
                                    Float32Array magResponse,
                                    Float32Array phaseResponse);
};

IIRFilterNode(context, options)

When the constructor is called with a BaseAudioContext c and an option object option, the user agent MUST initialize the AudioNode this, with context and options as arguments.

getFrequencyResponse(frequencyHz, magResponse, phaseResponse)

Given the current filter parameter settings, synchronously calculates the frequency response for the specified frequencies. The three parameters MUST be Float32Arrays of the same length, or an InvalidAccessError MUST be thrown.

Arguments for the IIRFilterNode.getFrequencyResponse() method. Parameter Type Nullable Optional Description frequencyHz Float32Array ✘ ✘ This parameter specifies an array of frequencies, in Hz, at which the response values will be calculated. magResponse Float32Array ✘ ✘ This parameter specifies an output array receiving the linear magnitude response values. If a value in the frequencyHz parameter is not within [0, sampleRate/2], where sampleRate is the value of the sampleRate property of the AudioContext, the corresponding value at the same index of the magResponse array MUST be NaN. phaseResponse Float32Array ✘ ✘ This parameter specifies an output array receiving the phase response values in radians. If a value in the frequencyHz parameter is not within [0; sampleRate/2], where sampleRate is the value of the sampleRate property of the AudioContext, the corresponding value at the same index of the phaseResponse array MUST be NaN.

The IIRFilterOptions dictionary is used to specify the filter coefficients of the IIRFilterNode.

dictionary IIRFilterOptions : AudioNodeOptions {
    required sequence<double> feedforward;
    required sequence<double> feedback;
};

feedforward, of type sequence<double>

The feedforward coefficients for the IIRFilterNode. This member is required. See feedforward argument of createIIRFilter() for other constraints.

feedback, of type sequence<double>

The feedback coefficients for the IIRFilterNode. This member is required. See feedback argument of createIIRFilter() for other constraints.

Let \(b_m\) be the feedforward coefficients and \(a_n\) be the feedback coefficients specified by createIIRFilter() or the IIRFilterOptions dictionary for the constructor. Then the transfer function of the general IIR filter is given by

$$
    H(z) = \frac{\sum_{m=0}^{M} b_m z^{-m}}{\sum_{n=0}^{N} a_n z^{-n}}
$$

where \(M + 1\) is the length of the \(b\) array and \(N + 1\) is the length of the \(a\) array. The coefficient \(a_0\) MUST not be 0 (see feedback parameter for createIIRFilter()). At least one of \(b_m\) MUST be non-zero (see feedforward parameter for createIIRFilter()).

Equivalently, the time-domain equation is:

$$
    \sum_{k=0}^{N} a_k y(n-k) = \sum_{k=0}^{M} b_k x(n-k)
$$

The initial filter state is the all-zeroes state.

Note: The UA may produce a warning to notify the user that NaN values have occurred in the filter state. This is usually indicative of an unstable filter.

This interface represents an audio source from an audio or video element.

The number of channels of the output corresponds to the number of channels of the media referenced by the HTMLMediaElement. Thus, changes to the media element’s src attribute can change the number of channels output by this node.

If the sample rate of the HTMLMediaElement differs from the sample rate of the associated AudioContext, then the output from the HTMLMediaElement must be resampled to match the context’s sample rate.

A MediaElementAudioSourceNode is created given an HTMLMediaElement using the AudioContext createMediaElementSource() method or the mediaElement member of the MediaElementAudioSourceOptions dictionary for the constructor.

The number of channels of the single output equals the number of channels of the audio referenced by the HTMLMediaElement passed in as the argument to createMediaElementSource(), or is 1 if the HTMLMediaElement has no audio.

The HTMLMediaElement MUST behave in an identical fashion after the MediaElementAudioSourceNode has been created, except that the rendered audio will no longer be heard directly, but instead will be heard as a consequence of the MediaElementAudioSourceNode being connected through the routing graph. Thus pausing, seeking, volume, src attribute changes, and other aspects of the HTMLMediaElement MUST behave as they normally would if not used with a MediaElementAudioSourceNode.

const mediaElement = document.getElementById('mediaElementID');
const sourceNode = context.createMediaElementSource(mediaElement);
sourceNode.connect(filterNode);

[Exposed=Window]
interface MediaElementAudioSourceNode : AudioNode {
    constructor (AudioContext context, MediaElementAudioSourceOptions options);
    [SameObject] readonly attribute HTMLMediaElement mediaElement;
};

MediaElementAudioSourceNode(context, options)

1. initialize the AudioNode this, with context and options as arguments.

mediaElement, of type HTMLMediaElement, readonly

The HTMLMediaElement used when constructing this MediaElementAudioSourceNode.