The AudioContext Interface

This interface represents a set of AudioNode objects and their connections. It allows for arbitrary routing of signals to the AudioDestinationNode (what the user ultimately hears). Nodes are created from the context and are then connected together. In most use cases, only a single AudioContext is used per document.

suspended

The AudioContext is currently suspended (context time is not proceeding, audio hardware may be powered down/released).

running

Audio is being processed.

closed

The AudioContext has been released, and can no longer be used to process audio. All system audio resources have been released. Attempts to create new Nodes on the AudioContext will throw InvalidStateError. (AudioBuffers may still be created, through createBuffer or decodeAudioData.)

readonly attribute AudioDestinationNode destination

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.

readonly attribute float sampleRate

The sample rate (in sample-frames per second) at which the AudioContext 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.

readonly attribute double currentTime

This is a time in seconds which starts at zero when the context is created and increases in real-time. All scheduled times are relative to it. This is not a "transport" time which can be started, paused, and re-positioned. It is always moving forward. A GarageBand-like timeline transport system can be very easily built on top of this (in JavaScript). This time corresponds to an ever-increasing hardware timestamp.

readonly attribute AudioListener listener

An AudioListener which is used for 3D spatialization.

readonly attribute AudioContextState state

Describes the current state of the AudioContext. The context state MUST begin in "suspended", and transitions to "running" when system resources are acquired and audio has begun processing. For OfflineAudioContexts, the state will remain in "suspended" until startRendering() is called, at which point it will transition to "running", and then to "closed" once audio processing has completed and oncomplete has been fired.

When the state is "suspended", a call to resume() will cause a transition to "running", or a call to close() will cause a transition to "closed".

When the state is "running", a call to suspend() will cause a transition to "suspended", or a call to close() will cause a transition to "closed".

When the state is "closed", no further state transitions are possible.

Promise suspend()

Suspends the progression of time in the audio context, 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 let the audio hardware power down. 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. This method will cause an INVALID_STATE_ERR exception to be thrown if called on an OfflineAudioContext.

While the system 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. Audio Workers and ScriptProcessorNodes will simply not fire their onaudioprocess events while suspended, but will resume when 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.

Promise resume()

Resumes the progression of time in an audio context that has been suspended, which may involve re-priming the frame buffer contents. The promise resolves when the system has re-acquired (if necessary) access to audio hardware and has begun streaming to the destination, or immediately (with no other effect) if the context is already running. The promise is rejected if the context has been closed. If the context is not currently suspended, the promise will resolve. This method will cause an INVALID_STATE_ERR exception to be thrown if called on an OfflineAudioContext.

Promise close()

Closes the audio context, releasing any system audio resources used by the AudioContext. This will not automatically release all AudioContext-created objects, unless other references have been released as well; however, it will forcibly release any system audio resources that might prevent additional AudioContexts from being created and used, suspend the progression of audio time in the audio context, and stop processing audio data. The promise resolves when all AudioContext-creation-blocking resources have been released. This method will cause an INVALID_STATE_ERR exception to be thrown if called on an OfflineAudioContext.

attribute EventHandler onstatechange

A property used to set the EventHandler for an event that is dispatched to AudioContext when the state of the AudioContext has changed (i.e. when the corresponding promise would have resolved). An event of type Event 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.

AudioBuffer createBuffer()

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

unsigned long numberOfChannels

Determines how many channels the buffer will have. An implementation must support at least 32 channels.

unsigned long length

Determines the size of the buffer in sample-frames.

float sampleRate

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 22050 to 96000.

Promise<AudioBuffer> decodeAudioData()

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.

ArrayBuffer audioData

An ArrayBuffer containing compressed audio data

optional DecodeSuccessCallback successCallback

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.

optional DecodeErrorCallback errorCallback

A callback function which will be invoked if there is an error decoding the audio file.

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

The following steps must be performed:

1. Let promise be a new promise.
2. If audioData is null or not a valid ArrayBuffer:
   1. Let error be a DOMException whose name is NotSupportedError.
   2. Reject promise with error.
   3. If errorCallback is not missing, invoke errorCallback with error.
   4. Terminate this algorithm.
3. Neuter the audioData ArrayBuffer in such a way that JavaScript code may not access or modify the data anymore.
4. Queue a decoding operation to be performed on another thread.
5. Return promise.
6. In the decoding thread:
   1. Attempt to decode the encoded audioData into linear PCM.
   2. If a decoding error is encountered due to the audio format not being recognized or supported, or because of corrupted/unexpected/inconsistent data, then, on the main thread's event loop:
      1. Let error be a DOMException whose name is "EncodingError".
      2. Reject promise with error.
      3. If errorCallback is not missing, invoke errorCallback with error.
   3. Otherwise:
      1. Take the result, representing the decoded linear PCM audio data, and resample it to the sample-rate of the AudioContext if it is different from the sample-rate of audioData.
      2. On the main thread's event loop:
         1. Let buffer be an AudioBuffer containing the final result (after possibly sample-rate converting).
         2. Resolve promise with buffer.
         3. If successCallback is not missing, invoke successCallback with buffer.

AudioBufferSourceNode createBufferSource()

Creates an AudioBufferSourceNode.

MediaElementAudioSourceNode createMediaElementSource()

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.

HTMLMediaElement mediaElement

The media element that will be re-routed.

MediaStreamAudioSourceNode createMediaStreamSource()

MediaStream mediaStream

The media stream that will act as source.

MediaStreamAudioDestinationNode createMediaStreamDestination()

Creates a MediaStreamAudioDestinationNode

AudioWorker createAudioWorker()

The createAudioWorker method creates an AudioWorker and its associated AudioWorkerGlobalScope for direct audio processing using JavaScript. An AudioWorker acts as a factory for AudioWorkerNode instances, allowing the nodes to be created synchronously on demand. Because script loading must be performed asynchronously, newly created nodes may not be able to process audio immediately on creation. However once the AudioWorker's script has been loaded and run, which can be detected via the event callback, nodes can be created with the assurance of no script-induced delays.

DOMString scriptURL

This parameter represents the URL of the script to be loaded as an AudioWorker.

ScriptProcessorNode createScriptProcessor()

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

optional unsigned long bufferSize = 0

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.

optional unsigned long numberOfInputChannels = 2

This parameter determines the number of channels for this node's input. Values of up to 32 must be supported.

optional unsigned long numberOfOutputChannels = 2

This parameter determines the number of channels for this node's output. Values of up to 32 must be supported.

It is invalid for both numberOfInputChannels and numberOfOutputChannels to be zero.

AnalyserNode createAnalyser()

Create an AnalyserNode.

GainNode createGain()

Create an GainNode.

DelayNode createDelay()

Creates a DelayNode representing a variable delay line. The initial default delay time will be 0 seconds.

optional double maxDelayTime = 1.0

The maxDelayTime parameter is optional and 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.

BiquadFilterNode createBiquadFilter()

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

WaveShaperNode createWaveShaper()

Creates a WaveShaperNode representing a non-linear distortion.

PannerNode createPanner()

Creates a PannerNode.

StereoPannerNode createStereoPanner()

Creates a StereoPannerNode.

ConvolverNode createConvolver()

Creates a ConvolverNode.

ChannelSplitterNode createChannelSplitter()

Creates an ChannelSplitterNode representing a channel splitter. An IndexSizeError exception MUST be thrown for invalid parameter values.

optional unsigned long numberOfOutputs = 6

The number of outputs. Values of up to 32 must be supported. If not specified, then 6 will be used.

ChannelMergerNode createChannelMerger()

Creates a ChannelMergerNode representing a channel merger. An IndexSizeError exception MUST be thrown for invalid parameter values.

optional unsigned long numberOfInputs = 6

The numberOfInputs parameter determines the number of inputs. Values of up to 32 must be supported. If not specified, then 6 will be used.

DynamicsCompressorNode createDynamicsCompressor()

Creates a DynamicsCompressorNode

OscillatorNode createOscillator()

Creates an OscillatorNode

PeriodicWave createPeriodicWave()

Creates a PeriodicWave representing a waveform containing arbitrary harmonic content. The real and imag parameters must be of type Float32Array (described in [[!TYPED-ARRAYS]]) of equal lengths greater than zero and less than or equal to 4096 or an IndexSizeError exception MUST be thrown. These parameters specify the Fourier coefficients of a Fourier series representing the partials of a periodic waveform. The created PeriodicWave will be used with an OscillatorNode and will represent a normalized time-domain waveform having maximum absolute peak value of 1. Another way of saying this is that the generated waveform of an OscillatorNode will have maximum peak value at 0dBFS. Conveniently, this corresponds to the full-range of the signal values used by the Web Audio API. Because the PeriodicWave will be normalized on creation, the real and imag parameters represent relative values.

As PeriodicWave objects maintain their own representation, any modification of the arrays uses as the real and imag parameters after the call to createPeriodicWave() will have no effect on the PeriodicWave object.

Float32Array real

The real parameter represents an array of cosine terms (traditionally the A terms). In audio terminology, the first element (index 0) is the DC-offset of the periodic waveform and is usually set to zero. The second element (index 1) represents the fundamental frequency. The third element represents the first overtone, and so on.

Float32Array imag

The imag parameter represents an array of sine terms (traditionally the B terms). The first element (index 0) should be set to zero (and will be ignored) since this term does not exist in the Fourier series. The second element (index 1) represents the fundamental frequency. The third element represents the first overtone, and so on.

AudioBuffer decodedData

The AudioBuffer containing the decoded audio data.

DOMException error

The error that occurred while decoding.

The OfflineAudioContext Interface

OfflineAudioContext is a particular type of AudioContext 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.

Each OfflineAudioContext instance has an associated rendering started flag that is initially false.

Promise<AudioBuffer> 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.

The following steps must be performed:

1. If this instance's rendering started flag is true, return a promise rejected with a DOMException whose name is "InvalidStateError".
2. Set this instance's rendering started flag to true.
3. Let promise be a new promise.
4. Asynchronously perform the following steps:
   1. Let buffer be a new AudioBuffer, with a number of channels, length and sample rate equal respectively to the numberOfChannels, length and sampleRate parameters used when this instance's constructor was called.
   2. Given the current connections and scheduled changes, start rendering length sample-frames of audio into buffer.
   3. Once the rendering is complete,
      1. Resolve promise with buffer.
      2. Fire a simple event named complete at this instance, using an instance of OfflineAudioCompletionEvent whose renderedBuffer property is set to buffer.
5. Return promise.

attribute EventHandler oncomplete

An EventHandler of type OfflineAudioCompletionEvent.

The AudioNode Interface

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. An AudioDestinationNode has one input and no outputs and represents the final destination to the audio hardware. 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 (usually an up-mixing) of all connections to that input. Please see for more informative details, and the section for normative requirements.

For performance reasons, practical implementations will need to use block processing, with each AudioNode processing a fixed number of sample-frames of size block-size. In order to get uniform behavior across implementations, we will define this value explicitly. block-size is defined to be 128 sample-frames which corresponds to roughly 3ms at a sample-rate of 44.1KHz.

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

max

computedNumberOfChannels is computed as the maximum of the number of channels of all connections. In this mode channelCount is ignored

clamped-max

Same as “max” up to a limit of the channelCount

explicit

computedNumberOfChannels is the exact value as specified in channelCount

speakers

use up-down-mix equations for mono/stereo/quad/5.1. In cases where the number of channels do not match any of these basic speaker layouts, revert to "discrete".

discrete

Up-mix by filling channels until they run out then zero out remaining channels. down-mix by filling as many channels as possible, then dropping remaining channels.

void connect()

AudioNode destination

The destination parameter is the AudioNode to connect to.

optional unsigned long output = 0

The output parameter is an index describing which output of the AudioNode from which to connect. If this paremeter is out-of-bound, an IndexSizeError exception MUST be thrown. It is possible to connect an AudioNode output to more than one input with multiple calls to connect(). Thus, "fan-out" is supported.

optional unsigned long input = 0

The input parameter is an index describing which input of the destination AudioNode to connect to. If this parameter is out-of-bounds, an IndexSizeError exception MUST be thrown. It is possible to connect an AudioNode to another AudioNode which creates a cycle: an AudioNode may connect to another AudioNode, which in turn connects back to the first AudioNode. This is allowed only if there is at least one DelayNode in the cycle or a NotSupportedError exception MUST be thrown.

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);
    

void connect()

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

AudioParam destination

The destination parameter is the AudioParam to connect to.

optional unsigned long output = 0

The output parameter is an index describing which output of the AudioNode from which to connect. If the parameter is out-of-bound, an IndexSizeError exception MUST be thrown.

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.

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);
    

void disconnect()

optional unsigned long output = 0

This parameter is an index describing which output of the AudioNode to disconnect. If this parameter is out-of-bounds, an IndexSizeError exception MUST be thrown.

readonly attribute AudioContext context

The AudioContext which owns this AudioNode.

readonly attribute unsigned long numberOfInputs

The number of inputs feeding into the AudioNode. For source nodes, this will be 0.

readonly attribute unsigned long numberOfOutputs

The number of outputs coming out of the AudioNode. This will be 0 for an AudioDestinationNode.

attribute unsigned long channelCount

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, the implementation MUST throw a NotSupportedError exception.

See the section for more information on this attribute.

attribute ChannelCountMode channelCountMode

Determines how channels will be counted when up-mixing and down-mixing connections to any inputs to the node. This attribute has no effect for nodes with no inputs.

See the section for more information on this attribute.

attribute ChannelInterpretation channelInterpretation

Determines how individual channels will be treated when up-mixing and down-mixing connections to any inputs to the node. This attribute has no effect for nodes with no inputs.

See the section for more information on this attribute.

The AudioDestinationNode Interface

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.

      numberOfInputs  : 1
      numberOfOutputs : 0

      channelCount = 2;
      channelCountMode = "explicit";
      channelInterpretation = "speakers";

readonly attribute unsigned long maxChannelCount

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. If this value is 0, then this indicates that channelCount may not be changed. This will be the case for an AudioDestinationNode in an OfflineAudioContext and also for basic implementations with hardware support for stereo output only.

channelCount defaults to 2 for a destination in a normal AudioContext, and may be set to any non-zero 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 anAudioDestinationNode in an OfflineAudioContext, the channelCount is determined when the offline context is created and this value may not be changed.

The AudioParam Interface

AudioParam controls an individual aspect of an AudioNode's functioning, 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 128 sample-frames in each block.

For each 128 sample-frame block, 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.

An AudioParam maintains a time-ordered event list which is initially empty. The times are in the time coordinate system of the AudioContext's currentTime attribute. The events define a mapping from time to value. The following methods can change the event list by adding a new event into the list of a type specific to the method. Each event has a time associated with it, and the events will always be kept in time-order in the list. These methods will be called automation methods:

• setValueAtTime() - SetValue
• linearRampToValueAtTime() - LinearRampToValue
• exponentialRampToValueAtTime() - ExponentialRampToValue
• setTargetAtTime() - SetTarget
• setValueCurveAtTime() - SetValueCurve

The following rules will apply when calling these methods:

• If one of these events is added at a time where there is already an event of the exact same type, then the new event will replace the old one.
• If one of these events is added at a time where there is already one or more events of a different type, 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 greater than T, but 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.
• Similarly a NotSupportedError exception MUST be thrown if any automation method is called at a time which is inside of the time interval of a SetValueCurve event at time T and duration D.

attribute float value

The parameter's floating-point value. This attribute is initialized to the defaultValue. If value is set during a time when there are any automation events scheduled then it will be ignored and no exception will be thrown.

readonly attribute float defaultValue

Initial value for the value attribute.

void setValueAtTime(float value, double startTime)

Schedules a parameter value change at the given time.

The value parameter is the value the parameter will change to at the given time.

The startTime parameter is the time in the same time coordinate system as the AudioContext's currentTime attribute. An InvalidAccessError exception MUST be thrown if startTime is negative or is not a finite number.

If there are no more events after this SetValue event, then for t >= startTime, v(t) = value. In other words, the value will remain constant.

If the next event (having time T1) after this SetValue event is not of type LinearRampToValue or ExponentialRampToValue, then, for t:

      startTime <= t < T1,  v(t) = value
    

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 details below.

void linearRampToValueAtTime(float value, double endTime)

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

The value parameter is the value the parameter will linearly ramp to at the given time.

The endTime parameter is the time in the same time coordinate system as the AudioContext's currentTime attribute. An InvalidAccessError exception MUST be thrown if endTime is negative or is not a finite number.

The value during the time interval T0 <= t < T1 (where T0 is the time of the previous event and T1 is the endTime parameter passed into this method) will be calculated as:

      v(t) = V0 + (V1 - V0) * ((t - T0) / (T1 - T0))
    

Where V0 is the value at the time T0 and V1 is the value parameter passed into this method.

If there are no more events after this LinearRampToValue event then for t >= T1, v(t) = V1.

void exponentialRampToValueAtTime(float value, double 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 parameter is the value the parameter will exponentially ramp to at the given time. A NotSupportedError exception MUST be thrown if this value is less than or equal to 0, or if the value at the time of the previous event is less than or equal to 0.

The endTime parameter is the time in the same time coordinate system as the AudioContext's currentTime attribute. An InvalidAccessError exception MUST be thrown if endTime is negative or is not a finite number.

The value during the time interval T0 <= t < T1 (where T0 is the time of the previous event and T1 is the endTime parameter passed into this method) will be calculated as:

        v(t) = V0 * (V1 / V0) ^ ((t - T0) / (T1 - T0))
    

Where V0 is the value at the time T0 and V1 is the value parameter passed into this method.

If there are no more events after this ExponentialRampToValue event then for t >= T1, v(t) = V1

void setTargetAtTime(float target, double startTime, float 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.

The target parameter is the value the parameter will start changing to at the given time.

The startTime parameter is the time in the same time coordinate system as the AudioContext's currentTime attribute. An InvalidAccessError exception MUST be thrown if start is negative or is not a finite number.

The timeConstant parameter is 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.

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).

During the time interval: T0 <= t < T1, where T0 is the startTime parameter and T1 represents the time of the event following this event (or infinity if there are no following events):

    v(t) = V1 + (V0 - V1) * exp(-(t - T0) / timeConstant)
    

Where V0 is the initial value (the .value attribute) at T0 (the startTime parameter) and V1 is equal to the target parameter.

void setValueCurveAtTime(Float32Array values, double startTime, double 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.

The values parameter is a Float32Array representing a parameter value curve. These values will apply starting at the given time and lasting for the given duration. Any modification to the the array used as values argument after the call won't have any effect on the AudioParam.

The startTime parameter is the time in the same time coordinate system as the AudioContext's currentTime attribute. An InvalidAccessError exception MUST be thrown if startTime is negative or is not a finite number.

The duration parameter is the amount of time in seconds (after the time parameter) where values will be calculated according to the values parameter.

During the time interval: startTime <= t < startTime + duration, values will be calculated:

        v(t) = values[N * (t - startTime) / duration]
      

where N is the length of the values array.

After the end of the curve time interval (t >= startTime + duration), the value will remain constant at the final curve value, until there is another automation event (if any).

void cancelScheduledValues(double startTime)

Cancels all scheduled parameter changes with times greater than or equal to startTime.

The startTime parameter is the starting time at and after which any previously scheduled parameter changes will be cancelled. It is a time in the same time coordinate system as the AudioContext's currentTime attribute. An InvalidAccessError exception MUST be thrown if startTime is negative or is not a finite number.

AudioParam Automation Example

var t0 = 0;
var t1 = 0.1;
var t2 = 0.2;
var t3 = 0.3;
var t4 = 0.4;
var t5 = 0.6;
var t6 = 0.7;
var t7 = 1.0;

var curveLength = 44100;
var curve = new Float32Array(curveLength);
for (var i = 0; i < curveLength; ++i)
    curve[i] = Math.sin(Math.PI * i / curveLength);

param.setValueAtTime(0.2, t0);
param.setValueAtTime(0.3, t1);
param.setValueAtTime(0.4, t2);
param.linearRampToValueAtTime(1, t3);
param.linearRampToValueAtTime(0.15, t4);
param.exponentialRampToValueAtTime(0.75, t5);
param.exponentialRampToValueAtTime(0.05, t6);
param.setValueCurveAtTime(curve, t6, t7 - t6);

The GainNode Interface

Changing the gain of an audio signal is a fundamental operation in audio applications. The GainNode is one of the building blocks for creating mixers. This interface is an AudioNode with a single input and single output:

  numberOfInputs  : 1
  numberOfOutputs : 1

  channelCountMode = "max";
  channelInterpretation = "speakers";

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

The implementation must make gain changes to the audio stream smoothly, without introducing noticeable clicks or glitches. This process is called "de-zippering".

readonly attribute AudioParam gain

Represents the amount of gain to apply. Its default value is 1 (no gain change). The nominal minValue is 0, but may be set negative for phase inversion. The nominal maxValue is 1, but higher values are allowed (no exception thrown).This parameter is a-rate

The DelayNode Interface

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

    numberOfInputs  : 1
    numberOfOutputs : 1

    channelCountMode = "max";
    channelInterpretation = "speakers";

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 delay time is changed, the implementation must make the transition smoothly, without introducing noticeable clicks or glitches to the audio stream.

readonly attribute AudioParam delayTime

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.

If DelayNode is part of a cycle, then the value of the delayTime attribute is clamped to a minimum of 128 frames (one block).

This parameter is a-rate.

The AudioBuffer Interface

This interface represents a memory-resident audio asset (for one-shot sounds and other short audio clips). Its format is non-interleaved IEEE 32-bit linear PCM with a nominal range of -1 -> +1. It can contain one or more channels. 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.

readonly attribute float sampleRate

The sample-rate for the PCM audio data in samples per second.

readonly attribute long length

Length of the PCM audio data in sample-frames.

readonly attribute double duration

Duration of the PCM audio data in seconds.

readonly attribute long numberOfChannels

The number of discrete audio channels.

Float32Array getChannelData()

Returns the Float32Array representing the PCM audio data for the specific channel.

unsigned long channel

This parameter is an index representing the particular channel to get data for. An index value of 0 represents the first channel. This index value MUST be less than numberOfChannels or an IndexSizeError exception MUST be thrown.

void copyFromChannel()

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

Float32Array destination

The array the channel data will be copied to.

long channelNumber

The index of the channel to copy the data from. If channelNumber is greater or equal than the number of channel of the AudioBuffer, an IndexSizeError MUST be thrown.

optional unsigned long startInChannel = 0

An optional offset to copy the data from. If startInChannel is greater than the length of the AudioBuffer, an IndexSizeError MUST be thrown.

void copyToChannel()

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

Float32Array source

The array the channel data will be copied from.

long channelNumber

The index of the channel to copy the data to. If channelNumber is greater or equal than the number of channel of the AudioBuffer, an IndexSizeError MUST be thrown.

optional unsigned long startInChannel = 0

An optional offset to copy the data to. If startInChannel is greater than the length of the AudioBuffer, an IndexSizeError MUST be thrown.

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.

When an acquire the content operation occurs on an AudioBuffer, run the following steps:

1. If any of the AudioBuffer's ArrayBuffer have been neutered, abort these steps, and return a zero-length channel data buffers to the invoker.
2. Neuter all ArrayBuffers for arrays previously returned by getChannelData on this AudioBuffer.
3. Retain the underlying data buffers from those ArrayBuffers and return references to them to the invoker.
4. Attach ArrayBuffers containing copies of the data to the AudioBuffer, to be returned by the next call to getChannelData.

• When AudioBufferSourceNode.start is called, it acquires the contents of the node's buffer. If the operation fails, nothing is played.
• When a ConvolverNode's buffer is set to an AudioBuffer while the node is connected to an output node, or a ConvolverNode is connected to an output node while the 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.

The AudioBufferSourceNode Interface

This interface represents an audio source from an in-memory audio asset in an AudioBuffer. It is useful for playing short audio assets which require a high degree of scheduling flexibility (can playback in rhythmically perfect ways). The start() method is used to schedule when sound playback will happen. 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() description. start() and stop() may not be issued multiple times for a given AudioBufferSourceNode.

  numberOfInputs  : 0
  numberOfOutputs : 1

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

attribute AudioBuffer? buffer

Represents the audio asset to be played.

readonly attribute AudioParam playbackRate

The speed at which to render the audio stream. Its default value is 1. This parameter is k-rate.

readonly attribute AudioParam detune

An aditional parameter to modulate the speed at which is rendered the audio stream. Its default value is 0. Its nominal range is [-1200; 1200]. This parameter is k-rate.

attribute boolean loop

Indicates if the audio data should play in a loop. The default value is false.

attribute double loopStart

An optional value in seconds 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.

attribute double loopEnd

An optional value in seconds where looping should end 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.

void start()

Schedules a sound to playback at an exact time.

optional double when = 0

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. start may only be called one time and must be called before stop is called or an InvalidStateError exception MUST be thrown. An InvalidAccessError exception MUST be thrown if when is negative or is not a finite number.

optional double offset = 0

The offset parameter describes the offset time in the buffer (in seconds) where playback will begin. If 0 is passed in for this value, then playback will start from the beginning of the buffer. An InvalidAccessError exception MUST be thrown if offset is negative or is not a finite number.

optional double duration

The duration parameter describes the duration of the portion (in seconds) to be played. If this parameter is not passed, the duration will be equal to the total duration of the AudioBuffer minus the offset parameter. Thus if neither offset nor duration are specified then the implied duration is the total duration of the AudioBuffer. An InvalidAccessError exception MUST be thrown if duration is negative or is not a finite number.

void stop()

Schedules a sound to stop playback at an exact time.

optional double when = 0

The when parameter describes at what time (in seconds) the sound 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. An InvalidAccessError exception MUST be thrown if when is negative or is not a finite number. If stop is called again after already have 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.

attribute EventHandler onended

A property used to set the EventHandler (described in HTML[[!HTML]]) for the ended event that is dispatched to AudioBufferSourceNode node types. When the playback of the buffer for an AudioBufferSourceNode is finished, an event of type Event (described in HTML [[!HTML]]) will be dispatched to the event handler.

Both playbackRate and detune are k-rate parameters and are used together to determine a computedPlaybackRate value:

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

The MediaElementAudioSourceNode Interface

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

  numberOfInputs  : 0
  numberOfOutputs : 1

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 .src attribute is not set, then the number of channels output will be one silent channel.

A MediaElementAudioSourceNode is created given an HTMLMediaElement using the AudioContext createMediaElementSource() method.

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.

  var mediaElement = document.getElementById('mediaElementID');
  var sourceNode = context.createMediaElementSource(mediaElement);
  sourceNode.connect(filterNode);

The AudioWorker

AudioWorker is an interface obtainable from AudioContext's createAudioWorker method. It represents the main thread's view of an associated audio processing worker script, which is hosted inside a corresponding AudioWorkerGlobalScope and runs in the audio processing thread. AudioWorkers act as factories for creating AudioWorkerNodes.

attribute EventHandler onload

An EventHandler of type Event that is notified after the script of thsw AudioWorker has been loaded and fully executed.

readonly attribute AudioContext context

The AudioContext from which this AudioWorker was created.

AudioParam addParameter(DOMString name, optional float defaultValue)

Causes a correspondingly-named read-only AudioParam to be present on all AudioWorkerNodes created by this AudioWorker, and a correspondingly-named read-only Float32Array to be present on the parameters object exposed on the AudioProcessEvent on subsequent audio processing events. The AudioParam may immediately have its scheduling methods called, its .value set, or AudioNodes connected to it.

The name parameter is the name used for the read-only AudioParam added to the AudioWorkerNode, and the name used for the read-only Float32Array that will be present on the parameters object exposed on subsequent AudioProcessEvents.

The defaultValue parameter is the default value for the AudioParam's value attribute, as well as therefore the default value that will appear in the Float32Array in the worker script (if no other parameter changes or connections affect the value).

void removeParameter(DOMString name)

(Propose removing from spec pending understanding of use case, since this is no longer a per-node action.)

void setNodeConfiguration(inputs, outputs)

Determines the input and output configuration and channel count of all nodes created by this AudioWorker. If not called, the configuration defaults to a single input and single output, each with 2 channels (as if setNodeConfiguration() had been called with no arguments).

optional Array inputs = null

This parameter determines the number of inputs for the worker, as well as the default number of channels for that input. The number of inputs cannot be changed once the node is created, although the number of channels in each input can be (see onprocess for more detail). The parameter is an Array whose length determines the number of inputs; each member of this Array will be coerced to an integer representing the default number of channels for the given input. Channel counts of up to 32 must be supported; values outside the supported range should throw NotSupportedError.

A null Array is treated the same as "[2]" - that is, it will default to a single input with two channels.

An empty Array is explicitly supported, and will cause the node to have no inputs - i.e., any attempt to connect() to this node will fail. (This is useful for nodes that function only as sources, such as an oscillator.)

optional Array outputs = null

This parameter determines the number of outputs for the worker, as well as the default number of channels for each output. The number of outputs cannot be changed once the node is created, although the number of channels in each output can be (see onprocess for more detail). The parameter is an Array whose length determines the number of outputs; each member of this Array will be coerced to an integer representing the default number of channels for the given output. Channel counts of up to 32 must be supported; values outside the supported range should throw NotSupportedError.

A null Array is treated the same as "[2]" - that is, it will default to a single output with two channels.

An empty Array is explicitly supported, and will cause the node to have no inputs - i.e., any attempt to connect() to this node will fail. (This is useful for nodes that function only as sources, such as an oscillator.)

It is invalid for both the number of inputs and number of outputs to be zero (i.e. both Arrays are empty). In this case, implementations should throw NotSupportedError.

Examples of usage:

• setNodeConfiguration() determines a single stereo input with a single stereo output.
• setNodeConfiguration( [1], [] ) creates a single mono input with no output.
• setNodeConfiguration( [1], [1] ) also creates a single mono input with a single mono output.
• setNodeConfiguration( [1], [2] ) creates a single mono input with a stereo output.
• setNodeConfiguration( [2,1], [2] ) creates two inputs - one stereo, one mono - and a stereo output.
• setNodeConfiguration( [1,1,1,1,1,1], [6] ) creates six mono inputs with a single 6-channel output. (This is similar to a 6-channel ChannelMergerNode.)
• setNodeConfiguration( [6], [1,1,1,1,1,1] ) creates a single 6-channel input with six mono outputs. (This is similar to a 6-channel ChannelSplitterNode.)

AudioWorkerNode createAudioWorkerNode()

Creates a new AudioWorkerNode that exhibits the previously parameters and input/output configuration for this AudioWorker. The node is available immediately for use. Following this call, an AudioNodeCreatedEvent is dispatched that creates the audio thread side of the node; this notification is delayed until the worker's script has loaded and run an any onload events have been dispatched. The node does not actually begin to process audio until all creation event processing has completed and an onaudioprocess handler has been attached to the node.

void terminate()

The terminate() method, when invoked, must cause the "terminate a worker" algorithm to be run on the worker with which the object is associated. This will cease any AudioProcessEvents being dispatched to the AudioWorker, and will cause the destruction of the associated AudioWorkerGlobalScope. In practical terms, this means all nodes created by this AudioWorker will be disconnected from any downstream connections.

The AudioWorkerNode Interface

This interface represents an AudioNode which interacts with an AudioWorker thread to generate, process, or analyse audio directly. An AudioWorkerNode is represented in the audio thread by an AudioWorkerNodeHandle.

Nota bene that if the Web Audio implementation normally runs audio process at higher than normal thread priority, utilizing AudioWorkerNodes may cause demotion of the priority of the audio thread (since user scripts cannot be run with higher than normal priority).

    numberOfInputs  : variable
    numberOfOutputs : variable

    channelCount = numberOfInputChannels;
    channelCountMode = "explicit";
    channelInterpretation = "speakers";

Example usage:

    var node = context.createAudioWorker( "inverter.js" ).createAudioWorkerNode();
  });

void postMessage(any message, optional sequence<Transferable> transfer)

postMessage may be called to send a message to the Audio Worker, via the algorithm defined by the Worker specification.

attribute EventHandler onmessage

The onmessage handler is called whenever the Audio Worker posts a message back to the main thread.

Note that AudioWorkerNode objects will also have read-only AudioParam objects for each named parameter added via the addParameter method. As this is dynamic, it cannot be captured in IDL.

AudioWorkerNodes must implement the Worker interface for communication with the audio worker script.

The AudioWorkerGlobalScope Interface

This interface is a DedicatedWorkerGlobalScope-derived object representing the context in which audio processing scripts are run for nodes created from a given AudioWorker; it is designed to enable the generation, processing, and analysis of audio data directly using JavaScript in a Worker thread.

The AudioWorkerGlobalScope has an audionodecreated event that is dispatched when new AudioNodes are created on the main thread.

attribute EventHandler onaudionodecreated

A property used to set the EventHandler (described in HTML[[!HTML]]) for the audionodecreated event that is dispatched to AudioWorkerGlobalScope when a new AudioWorkerNode is created. An event of type AudioNodeCreatedEvent will be dispatched to the event handler.

readonly attribute float sampleRate

The sample rate of the host AudioContext (since inside the Worker scope, the user will not have direct access to the AudioContext.

The AudioWorkerNodeHandle Interface

This interface represents the audio thread side of an AudioWorkerNode within an AudioWorkerGlobalScope.

The AudioWorkerNodeHandle has an audioprocess event that is dispatched synchronously to process audio frames. audioprocess events are only dispatched if the AudioWorkerNode has at least one input or one output connected.

It also supports communication with its AudioWorkerNode in the main thread using onmessage and postMessage, allowing the node's behavior to be controlled by the application and letting the node send data to the application.

void postMessage(any message, optional sequence<Transferable> transfer)

postMessage may be called to send a message to the main thread, via the algorithm defined by the Worker specification.

attribute EventHandler onmessage

The onmessage handler is called whenever the main thread posts a message to the AudioWorkerNode to which this AudioWorkerNodeHandle corresponds.

attribute EventHandler onaudioprocess

A property used to set the EventHandler (described in HTML[[!HTML]]) for the audioprocess event that is dispatched to AudioWorkerGlobalScope when the associated AudioWorkerNode is connected. An event of type AudioProcessEvent will be dispatched to the event handler. Setting this attribute to null will prevent further audio processing by the node and make the node eligible for garbage collection.

FFT Windowing and smoothing over time

1. Apply a Blackman window to the time domain input data
2. Apply a Fourier tranform to the windowed time domain input data to get imaginary and real frequency data
3. Smooth over time the frequency domain data

function blackmanWindow(buffer) {
  var alpha = 0.16;
  var a0 = 0.5 * (1.0 - alpha);
  var a1 = 0.5;
  var a2 = 0.5 * alpha;

  for (var i = 0; i < buffer.length; i++) {
    var x = i / buffer.length;
    buffer[i] *= a0 - a1 * Math.cos(2 * Math.PI * x) + a2 * Math.cos(4 * Math.PI * x);
  }
}
    

• Let fftSize be the value of fftSize for this AnalyserNode.
• Let outputBuffer be an array that contains the frequency data that will be made available to the author via getFloatFrequencyData, or getByteFrequencyData.
• Let lastOutputBuffer be the result of this operation on the previous block. The previous block is defined as being the buffer returned by the previous smoothing over time operation, or an array of fftSize zeros if this is the first time we are smoothing over time.
• Let smoothingConstant be the value of the smoothingTimeConstant attribute for this AnalyserNode.
• Let real and imag be two arrays of length fftSize, that contain the result of the previously applied Fourier transform.

  function smoothingOverTime(outputBuffer, lastOutputBuffer,
                             smoothingConstant,
                             real, imag, fftSize) {
    for (var i = 0; i < outputBuffer.length; i++) {
      var magnitude = Math.sqrt(real[i] * real[i] + imag[i] * imag[i]) / fftSize;
      outputBuffer[i] = smoothingTimeConstant * lastOutputBuffer[i] + (1.0 - smoothingTimeConstant) * magnitude;
    }
  }

Filters characteristics

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 type. They are derived from formulas found in the Audio EQ Cookbook.

The transfer function for the filters implemented by the BiquadFilterNode is: $$H\left(z\right)=\frac{\left(\frac{b_0}{a_0}\right)+\left(\frac{b_1}{a_0}\right)\cdot z^{-1}+\left(\frac{b_2}{a_0}\right)\cdot z^{-2}}{1+\left(\frac{a_1}{a_0}\right)\cdot z^{-1}+\left(\frac{a_2}{a_0}\right)\cdot z^{-2}}$$ The initial filter state is 0.

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

• Let $F_{\mathrm{s}}$ be the value of the sampleRate attribute for this AudioContext.
• Let $f_0$ be the value of the computedFrequency.
• Let $\mathrm{dbGain}$ be the value of the gain AudioParam.
• Let $Q$ be the value of the Q AudioParam.
• Let $A$ be:
  • ${10}^{\frac{dBgain}{40}}$ for the filter types peaking, highshelf and lowshelf ;
  • $\sqrt{{10}^{\frac{dBgain}{20}}}$ otherwise.
• Let $A_1$ be
• Let ${\omega }_0$ be $2\cdot \pi \cdot \frac{f_0}{F_s}$.
• Let ${\alpha }_{\mathrm{Q}}$ be $\frac{\sin \left({\omega }_0\right)}{2\cdot Q}$
• Let ${\alpha }_{\mathrm{BW}}$ be $\sin \left({\omega }_0\right)\cdot \sinh (\frac{\ln \left(2\right)}{2}\cdot Q\cdot \frac{{\omega }_0}{\sin \left({\omega }_0\right)})$
• Let ${\alpha }_{\mathrm{S}}$ be $\frac{\sin \left({\omega }_0\right)}{2}\cdot \sqrt{(A+\frac{1}{A})\cdot (\frac{1}{Q}-1)+2}$

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

lowpass

$$\begin{array}{l}\\ b_0=\frac{1-cos\left({\omega }_0\right)}{2}\\ b_1=1-cos\left({\omega }_0\right)\\ b_2=\frac{1-cos\left({\omega }_0\right)}{2}\\ a_0=1+{\alpha }_{\mathrm{Q}}\\ a_1=-2\cdot cos\left({\omega }_0\right)\\ a_2=1-{\alpha }_{\mathrm{Q}}\end{array}$$

highpass

$$\begin{array}{l}\\ b_0=\frac{1+cos\left({\omega }_0\right)}{2}\\ b_1=-(1+cos\left({\omega }_0\right))\\ b_2=\frac{1+cos\left({\omega }_0\right)}{2}\\ a_0=1+{\alpha }_{\mathrm{Q}}\\ a_1=-2\cdot cos\left({\omega }_0\right)\\ a_2=1-{\alpha }_{\mathrm{Q}}\end{array}$$

bandpass

$$\begin{array}{l}\\ b_0={\alpha }_{\mathrm{BW}}\\ b_1=0\\ b_2=-{\alpha }_{\mathrm{BW}}\\ a_0=1+{\alpha }_{\mathrm{BW}}\\ a_1=-2\cdot cos\left({\omega }_0\right)\\ a_2=1-{\alpha }_{\mathrm{BW}}\end{array}$$

notch

$$\begin{array}{l}\\ b_0=1\\ b_1=-2\cdot cos\left({\omega }_0\right)\\ b_2=1\\ a_0=1+{\alpha }_{\mathrm{BW}}\\ a_1=-2\cdot cos\left({\omega }_0\right)\\ a_2=1-{\alpha }_{\mathrm{BW}}\end{array}$$

allpass

$$\begin{array}{l}\\ b_0=1-{\alpha }_{\mathrm{Q}}\\ b_1=-2\cdot cos\left({\omega }_0\right)\\ b_2=1+{\alpha }_{\mathrm{Q}}\\ a_0=1+{\alpha }_{\mathrm{Q}}\\ a_1=-2\cdot cos\left({\omega }_0\right)\\ a_2=1-{\alpha }_{\mathrm{Q}}\end{array}$$

peaking

$$\begin{array}{l}\\ b_0=1+{\alpha }_{\mathrm{BW}}\cdot A\\ b_1=-2\cdot cos\left({\omega }_0\right)\\ b_2=1-{\alpha }_{\mathrm{BW}}\cdot A\\ a_0=1+\frac{{\alpha }_{\mathrm{BW}}}{A}\\ a_1=-2\cdot cos\left({\omega }_0\right)\\ a_2=1-\frac{{\alpha }_{\mathrm{BW}}}{A}\end{array}$$

lowshelf

$$\begin{array}{l}\\ b_0=A\cdot ((A+1)-(A-1)\cdot cos\left({\omega }_0\right)+2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}})\\ b_1=2\cdot A\cdot ((A-1)-(A+1)\cdot cos\left({\omega }_0\right))\\ b_2=A\cdot ((A+1)-(A-1)\cdot cos\left({\omega }_0\right)-2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}})\\ a_0=(A+1)+(A-1)\cdot cos\left({\omega }_0\right)+2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}}\\ a_1=-2\cdot ((A-1)+(A+1)\cdot cos\left({\omega }_0\right))\\ a_2=(A+1)+(A-1)\cdot cos\left({\omega }_0\right)-2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}}\end{array}$$

highshelf

$$\begin{array}{l}\\ b_0=A\cdot ((A+1)+(A-1)\cdot cos\left({\omega }_0\right)+2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}})\\ b_1=-2\cdot A\cdot ((A-1)+(A+1)\cdot cos\left({\omega }_0\right))\\ b_2=A\cdot ((A+1)+(A-1)\cdot cos\left({\omega }_0\right)-2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}})\\ a_0=(A+1)-(A-1)\cdot cos\left({\omega }_0\right)+2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}}\\ a_1=2\cdot ((A-1)-(A+1)\cdot cos\left({\omega }_0\right))\\ a_2=(A+1)-(A-1)\cdot cos\left({\omega }_0\right)-2\cdot \sqrt{A}\cdot {\alpha }_{\mathrm{S}}\end{array}$$

Basic waveform phase

The idealized mathematical waveforms for the various oscillator types are defined here. In summary, all waveforms are defined mathematically to be an odd function with a positive slope at time 0. The actual waveforms produced by the oscillator may differ to prevent aliasing affects.

"sine"

The waveform for sine oscillator is sin(t).

"square"

The waveform for the square wave oscillator is 1 for 0≤ t < π and -1 for -π < t < 0.

"sawtooth"

The waveform for the sawtooth oscillator is the ramp t/π for -π < t ≤ π

"triangle"

The waveform for the triangle oscillator is 2/π*t for 0 ≤ t ≤ π/2 and 1-2/π*(t-π/2) for π/2 < t ≤ π. This is extended to all t by using the fact that the waveform is an odd function with period 2π.

Background

This section is non-normative. Please see AudioContext lifetime and AudioNode lifetime for normative requirements.

In addition to allowing the creation of static routing configurations, it should also be possible to do custom effect routing on dynamically allocated voices which have a limited lifetime. For the purposes of this discussion, let's call these short-lived voices "notes". Many audio applications incorporate the ideas of notes, examples being drum machines, sequencers, and 3D games with many one-shot sounds being triggered according to game play.

In a traditional software synthesizer, notes are dynamically allocated and released from a pool of available resources. The note is allocated when a MIDI note-on message is received. It is released when the note has finished playing either due to it having reached the end of its sample-data (if non-looping), it having reached a sustain phase of its envelope which is zero, or due to a MIDI note-off message putting it into the release phase of its envelope. In the MIDI note-off case, the note is not released immediately, but only when the release envelope phase has finished. At any given time, there can be a large number of notes playing but the set of notes is constantly changing as new notes are added into the routing graph, and old ones are released.

The audio system automatically deals with tearing-down the part of the routing graph for individual "note" events. A "note" is represented by an AudioBufferSourceNode, which can be directly connected to other processing nodes. When the note has finished playing, the context will automatically release the reference to the AudioBufferSourceNode, which in turn will release references to any nodes it is connected to, and so on. The nodes will automatically get disconnected from the graph and will be deleted when they have no more references. Nodes in the graph which are long-lived and shared between dynamic voices can be managed explicitly. Although it sounds complicated, this all happens automatically with no extra JavaScript handling required.

Example

The low-pass filter, panner, and second gain nodes are directly connected from the one-shot sound. So when it has finished playing the context will automatically release them (everything within the dotted line). If there are no longer any JavaScript references to the one-shot sound and connected nodes, then they will be immediately removed from the graph and deleted. The streaming source, has a global reference and will remain connected until it is explicitly disconnected. Here's how it might look in JavaScript:

var context = 0;
var compressor = 0;
var gainNode1 = 0;
var streamingAudioSource = 0;

// Initial setup of the "long-lived" part of the routing graph
function setupAudioContext() {
    context = new AudioContext();

    compressor = context.createDynamicsCompressor();
    gainNode1 = context.createGain();

    // Create a streaming audio source.
    var audioElement = document.getElementById('audioTagID');
    streamingAudioSource = context.createMediaElementSource(audioElement);
    streamingAudioSource.connect(gainNode1);

    gainNode1.connect(compressor);
    compressor.connect(context.destination);
}

// Later in response to some user action (typically mouse or key event)
// a one-shot sound can be played.
function playSound() {
    var oneShotSound = context.createBufferSource();
    oneShotSound.buffer = dogBarkingBuffer;

    // Create a filter, panner, and gain node.
    var lowpass = context.createBiquadFilter();
    var panner = context.createPanner();
    var gainNode2 = context.createGain();

    // Make connections
    oneShotSound.connect(lowpass);
    lowpass.connect(panner);
    panner.connect(gainNode2);
    gainNode2.connect(compressor);

    // Play 0.75 seconds from now (to play immediately pass in 0)
    oneShotSound.start(context.currentTime + 0.75);
}

Speaker Channel Layouts

When channelInterpretation is "speakers" then the up-mixing and down-mixing is defined for specific channel layouts.

Mono (one channel), stereo (two channels), quad (four channels), and 5.1 (six channels) MUST be supported. Other channel layout may be supported in future version of this specification.

Channel ordering

    Mono
      0: M: mono

    Stereo
      0: L: left
      1: R: right
    

  Quad
      0: L:  left
      1: R:  right
      2: SL: surround left
      3: SR: surround right

    5.1
      0: L:   left
      1: R:   right
      2: C:   center
      3: LFE: subwoofer
      4: SL:  surround left
      5: SR:  surround right
  

Up Mixing speaker layouts

Mono up-mix:

    1 -> 2 : up-mix from mono to stereo
        output.L = input;
        output.R = input;

    1 -> 4 : up-mix from mono to quad
        output.L = input;
        output.R = input;
        output.SL = 0;
        output.SR = 0;

    1 -> 5.1 : up-mix from mono to 5.1
        output.L = 0;
        output.R = 0;
        output.C = input; // put in center channel
        output.LFE = 0;
        output.SL = 0;
        output.SR = 0;

Stereo up-mix:

    2 -> 4 : up-mix from stereo to quad
        output.L = input.L;
        output.R = input.R;
        output.SL = 0;
        output.SR = 0;

    2 -> 5.1 : up-mix from stereo to 5.1
        output.L = input.L;
        output.R = input.R;
        output.C = 0;
        output.LFE = 0;
        output.SL = 0;
        output.SR = 0;

Quad up-mix:

    4 -> 5.1 : up-mix from quad to 5.1
        output.L = input.L;
        output.R = input.R;
        output.C = 0;
        output.LFE = 0;
        output.SL = input.SL;
        output.SR = input.SR;

Down Mixing speaker layouts

A down-mix will be necessary, for example, if processing 5.1 source material, but playing back stereo.

  Mono down-mix:

      2 -> 1 : stereo to mono
          output = 0.5 * (input.L + input.R);

      4 -> 1 : quad to mono
          output = 0.25 * (input.L + input.R + input.SL + input.SR);

      5.1 -> 1 : 5.1 to mono
          output = 0.7071 * (input.L + input.R) + input.C + 0.5 * (input.SL + input.SR)


  Stereo down-mix:

      4 -> 2 : quad to stereo
          output.L = 0.5 * (input.L + input.SL);
          output.R = 0.5 * (input.R + input.SR);

      5.1 -> 2 : 5.1 to stereo
          output.L = L + 0.7071 * (input.C + input.SL)
          output.R = R + 0.7071 * (input.C + input.SR)

  Quad down-mix:

      5.1 -> 4 : 5.1 to quad
          output.L = L + 0.7071 * input.C
          output.R = R + 0.7071 * input.C
          output.SL = input.SL
          output.SR = input.SR

  

Background

A common feature requirement for modern 3D games is the ability to dynamically spatialize and move multiple audio sources in 3D space. Game audio engines such as OpenAL, FMOD, Creative's EAX, Microsoft's XACT Audio, etc. have this ability.

Using an PannerNode, an audio stream can be spatialized or positioned in space relative to an AudioListener. An AudioContext will contain a single AudioListener. Both panners and listeners have a position in 3D space using a right-handed cartesian coordinate system. The units used in the coordinate system are not defined, and do not need to be because the effects calculated with these coordinates are independent/invariant of any particular units such as meters or feet. PannerNode objects (representing the source stream) have an orientation vector representing in which direction the sound is projecting. Additionally, they have a sound cone representing how directional the sound is. For example, the sound could be omnidirectional, in which case it would be heard anywhere regardless of its orientation, or it can be more directional and heard only if it is facing the listener. AudioListener objects (representing a person's ears) have an orientation and up vector representing in which direction the person is facing. Because both the source stream and the listener can be moving, they both have a velocity vector representing both the speed and direction of movement. Taken together, these two velocities can be used to generate a doppler shift effect which changes the pitch.

During rendering, the PannerNode calculates an azimuth and elevation. These values are used internally by the implementation in order to render the spatialization effect. See the Panning Algorithm section for details of how these values are used.

Azimuth and Elevation

The following algorithm must be used to calculate the azimuth and elevation: for the PannerNode

  // Calculate the source-listener vector.
  vec3 sourceListener = source.position - listener.position;

  if (sourceListener.isZero()) {
      // Handle degenerate case if source and listener are at the same point.
      azimuth = 0;
      elevation = 0;
      return;
  }

  sourceListener.normalize();

  // Align axes.
  vec3 listenerFront = listener.orientation;
  vec3 listenerUp = listener.up;
  vec3 listenerRight = listenerFront.cross(listenerUp);
  listenerRight.normalize();

  vec3 listenerFrontNorm = listenerFront;
  listenerFrontNorm.normalize();

  vec3 up = listenerRight.cross(listenerFrontNorm);

  float upProjection = sourceListener.dot(up);

  vec3 projectedSource = sourceListener - upProjection * up;
  projectedSource.normalize();

  azimuth = 180 * acos(projectedSource.dot(listenerRight)) / PI;

  // Source in front or behind the listener.
  float frontBack = projectedSource.dot(listenerFrontNorm);
  if (frontBack < 0)
      azimuth = 360 - azimuth;

  // Make azimuth relative to "front" and not "right" listener vector.
  if ((azimuth >= 0) && (azimuth <= 270))
      azimuth = 90 - azimuth;
  else
      azimuth = 450 - azimuth;

  elevation = 90 - 180 * acos(sourceListener.dot(up)) / PI;

  if (elevation > 90)
      elevation = 180 - elevation;
  else if (elevation < -90)
      elevation = -180 - elevation;
  

Panning Algorithm

mono->stereo and stereo->stereo panning must be supported. mono->stereo processing is used when all connections to the input are mono. Otherwise stereo->stereo processing is used.

The following algorithms must be implemented:

• Equal-power (Vector-based) panning

  This is a simple and relatively inexpensive algorithm which provides basic, but reasonable results. It is used for the StereoPannerNode, and for the PannerNode when the panningModel attribute is set to "equalpower", in which case the the elevation value is ignored.

  For a PannerNode, the following algorithm MUST be implemented.

  1. Let azimuth be the value computed in the azimuth and elevation section.

  2. The azimuth value is first contained to be within the range -90 <= azimuth <= +90 according to:

       // Clamp azimuth to allowed range of -180 -> +180.
       azimuth = max(-180, azimuth);
       azimuth = min(180, azimuth);
     
       // Now wrap to range -90 -> +90.
       if (azimuth < -90) {
           azimuth = -180 - azimuth;
       } else if (azimuth > 90) {
           azimuth = 180 - azimuth;
       }
             

  3. A 0 -> 1 normalized value x is calculated from azimuth for mono->stereo as:

       x = (azimuth + 90) / 180
             

     Or for stereo->stereo as:

       if (azimuth <= 0) { // from -90 -> 0
           // inputL -> outputL and "equal-power pan" inputR as in mono case
           // by transforming the "azimuth" value from -90 -> 0 degrees into the range -90 -> +90.
           x = (azimuth + 90) / 90;
       } else { // from 0 -> +90
           // inputR -> outputR and "equal-power pan" inputL as in mono case
           // by transforming the "azimuth" value from 0 -> +90 degrees into the range -90 -> +90.
           x = azimuth / 90;
       }
             

  For a StereoPannerNode, the following algorithm MUST be implemented.

  1. Let azimuth be the computedValue of the pan AudioParam of this StereoPannerNode.
  2. Normalize the azimuth value to [0; 1]. From mono to stereo:

       x = (azimuth + 1) / 2;
                 

     Or when panning stereo to stereo:

       if (azymuth <= 0) {
         x = azimuth + 1;
       } else {
         x = azimuth;
       }
                 

  Then following steps are used for processing:

  1. Left and right gain values are calculated:

       gainL = cos(0.5 * Math.PI * x);
       gainR = sin(0.5 * Math.PI * x);
               

  2. For mono->stereo, the output is calculated as:

       outputL = input * gainL;
       outputR = input * gainR;
               

     Else for stereo->stereo, the output is calculated as:

       if (azimuth <= 0) {
           outputL = inputL + inputR * gainL;
           outputR = inputR * gainR;
       } else {
           outputL = inputL * gainL;
           outputR = inputR + inputL * gainR;
       }
               

• HRTF panning (stereo only).

  This requires a set of HRTF impulse responses recorded at a variety of azimuths and elevations. There are a small number of open/free impulse responses available. The implementation requires a highly optimized convolution function. It is somewhat more costly than "equal-power", but provides a more spatialized sound.

  

Distance Effects

Sounds which are closer are louder, while sounds further away are quieter. Exactly how a sound's volume changes according to distance from the listener depends on the distanceModel attribute.

During audio rendering, a distance value will be calculated based on the panner and listener positions according to:

  v = panner.position - listener.position
  

  distance = sqrt(dot(v, v))
  

distance will then be used to calculate distanceGain which depends on the distanceModel attribute. See the distanceModel section for details of how this is calculated for each distance model.

As part of its processing, the PannerNode scales/multiplies the input audio signal by distanceGain to make distant sounds quieter and nearer ones louder.

Sound Cones

The listener and each sound source have an orientation vector describing which way they are facing. Each sound source's sound projection characteristics are described by an inner and outer "cone" describing the sound intensity as a function of the source/listener angle from the source's orientation vector. Thus, a sound source pointing directly at the listener will be louder than if it is pointed off-axis. Sound sources can also be omni-directional.

The following algorithm must be used to calculate the gain contribution due to the cone effect, given the source (the PannerNode) and the listener:

  if (source.orientation.isZero() || ((source.coneInnerAngle == 360) && (source.coneOuterAngle == 360)))
      return 1; // no cone specified - unity gain

  // Normalized source-listener vector
  vec3 sourceToListener = listener.position - source.position;
  sourceToListener.normalize();

  vec3 normalizedSourceOrientation = source.orientation;
  normalizedSourceOrientation.normalize();

  // Angle between the source orientation vector and the source-listener vector
  float dotProduct = sourceToListener.dot(normalizedSourceOrientation);
  float angle = 180 * acos(dotProduct) / PI;
  float absAngle = fabs(angle);

  // Divide by 2 here since API is entire angle (not half-angle)
  float absInnerAngle = fabs(source.coneInnerAngle) / 2;
  float absOuterAngle = fabs(source.coneOuterAngle) / 2;
  float gain = 1;

  if (absAngle <= absInnerAngle)
      // No attenuation
      gain = 1;
  else if (absAngle >= absOuterAngle)
      // Max attenuation
      gain = source.coneOuterGain;
  else {
      // Between inner and outer cones
      // inner -> outer, x goes from 0 -> 1
      float x = (absAngle - absInnerAngle) / (absOuterAngle - absInnerAngle);
      gain = (1 - x) + source.coneOuterGain * x;
  }

  return gain;
  

Doppler Shift

• Introduces a pitch shift which can realistically simulate moving sources.
• Depends on: source / listener velocity vectors, speed of sound, doppler factor.

The following algorithm must be used to calculate the doppler shift value which is used as an additional playback rate scalar for all AudioBufferSourceNodes connecting directly or indirectly to the PannerNode:

  float dopplerShift = 1; // Initialize to default value
  float dopplerFactor = listener.dopplerFactor;

  if (dopplerFactor > 0) {
      float speedOfSound = listener.speedOfSound;

      // Don't bother if both source and listener have no velocity.
      if (!source.velocity.isZero() || !listener.velocity.isZero()) {
          // Calculate the source to listener vector.
          vec3 sourceToListener = source.position - listener.position;

          float sourceListenerMagnitude = sourceToListener.length();

          float listenerProjection = sourceToListener.dot(listener.velocity) / sourceListenerMagnitude;
          float sourceProjection = sourceToListener.dot(source.velocity) / sourceListenerMagnitude;

          listenerProjection = -listenerProjection;
          sourceProjection = -sourceProjection;

          float scaledSpeedOfSound = speedOfSound / dopplerFactor;
          listenerProjection = min(listenerProjection, scaledSpeedOfSound);
          sourceProjection = min(sourceProjection, scaledSpeedOfSound);

          dopplerShift = ((speedOfSound - dopplerFactor * listenerProjection) / (speedOfSound - dopplerFactor * sourceProjection));
          fixNANs(dopplerShift); // Avoid illegal values

          // Limit the pitch shifting to 4 octaves up and 3 octaves down.
          dopplerShift = min(dopplerShift, 16);
          dopplerShift = max(dopplerShift, 0.125);
      }
  }
  

Background

Convolution is a mathematical process which can be applied to an audio signal to achieve many interesting high-quality linear effects. Very often, the effect is used to simulate an acoustic space such as a concert hall, cathedral, or outdoor amphitheater. It can also be used for complex filter effects, like a muffled sound coming from inside a closet, sound underwater, sound coming through a telephone, or playing through a vintage speaker cabinet. This technique is very commonly used in major motion picture and music production and is considered to be extremely versatile and of high quality.

Each unique effect is defined by an impulse response. An impulse response can be represented as an audio file and can be recorded from a real acoustic space such as a cave, or can be synthetically generated through a great variety of techniques.

Motivation for use as a Standard

A key feature of many game audio engines (OpenAL, FMOD, Creative's EAX, Microsoft's XACT Audio, etc.) is a reverberation effect for simulating the sound of being in an acoustic space. The code used to generate this effect has generally been custom and algorithmic (generally using a hand-tweaked set of delay lines and allpass filters which feedback into each other). In nearly all cases, not only is the implementation custom, but the code is proprietary and closed-source, each company adding its own "black magic" to achieve its unique quality. Each implementation being custom with a different set of parameters makes it impossible to achieve a uniform desired effect. And the code being proprietary makes it impossible to adopt a single one of the implementations as a standard. Additionally, algorithmic reverberation effects are limited to a relatively narrow range of different effects, regardless of how the parameters are tweaked.

A convolution effect solves these problems by using a very precisely defined mathematical algorithm as the basis of its processing. An impulse response represents an exact sound effect to be applied to an audio stream and is easily represented by an audio file which can be referenced by URL. The range of possible effects is enormous.

Implementation Guide

Linear convolution can be implemented efficiently. Here are some notes describing how it can be practically implemented.

Reverb Effect (with matrixing)

This section is normative.

In the general case the source has N input channels, the impulse response has K channels, and the playback system has M output channels. Thus it's a matter of how to matrix these channels to achieve the final result.

The subset of N, M, K below must be implemented (note that the first image in the diagram is just illustrating the general case and is not normative, while the following images are normative). Without loss of generality, developers desiring more complex and arbitrary matrixing can use multiple ConvolverNode objects in conjunction with an ChannelMergerNode.

Single channel convolution operates on a mono audio input, using a mono impulse response, and generating a mono output. To achieve a more spacious sound, 2 channel audio inputs and 1, 2, or 4 channel impulse responses will be considered. The following diagram, illustrates the common cases for stereo playback where N and M are 1 or 2 and K is 1, 2, or 4.

Performance Considerations

Latency

For web applications, the time delay between mouse and keyboard events (keydown, mousedown, etc.) and a sound being heard is important.

This time delay is called latency and is caused by several factors (input device latency, internal buffering latency, DSP processing latency, output device latency, distance of user's ears from speakers, etc.), and is cummulative. The larger this latency is, the less satisfying the user's experience is going to be. In the extreme, it can make musical production or game-play impossible. At moderate levels it can affect timing and give the impression of sounds lagging behind or the game being non-responsive. For musical applications the timing problems affect rhythm. For gaming, the timing problems affect precision of gameplay. For interactive applications, it generally cheapens the users experience much in the same way that very low animation frame-rates do. Depending on the application, a reasonable latency can be from as low as 3-6 milliseconds to 25-50 milliseconds.

Requirements and Use Cases

Please see Example Applications

Acknowledgements

This specification is the collective work of the W3C Audio Working Group.

Members of the Working Group are (at the time of writing, and by alphabetical order):
Adenot, Paul (Mozilla Foundation); Akhgari, Ehsan (Mozilla Foundation); Berkovitz, Joe (Invited Expert); Bossart, Pierre (Intel Corporation); Carlson, Eric (Apple, Inc.); Geelnard, Marcus (Opera Software); Goode, Adam (Google, Inc.); Gregan, Matthew (Mozilla Foundation); Jägenstedt, Philip (Opera Software); Kalliokoski, Jussi (Invited Expert); Lilley, Chris (W3C Staff); Lowis, Chris (Invited Expert. WG co-chair from December 2012 to September 2013, affiliated with British Broadcasting Corporation); Mandyam, Giridhar (Qualcomm Innovation Center, Inc); Noble, Jer (Apple, Inc.); O'Callahan, Robert(Mozilla Foundation); Onumonu, Anthony (British Broadcasting Corporation); Paradis, Matthew (British Broadcasting Corporation); Raman, T.V. (Google, Inc.); Schepers, Doug (W3C/MIT); Shires, Glen (Google, Inc.); Smith, Michael (W3C/Keio); Thereaux, Olivier (British Broadcasting Corporation) – WG Chair; Verdie, Jean-Charles (MStar Semiconductor, Inc.); Wilson, Chris (Google,Inc.); ZERGAOUI, Mohamed (INNOVIMAX)

Former members of the Working Group and contributors to the specification include:
Caceres, Marcos (Invited Expert); Cardoso, Gabriel (INRIA); Chen, Bin (Baidu, Inc.); MacDonald, Alistair (W3C Invited Experts) — WG co-chair from March 2011 to July 2012; Michel, Thierry (W3C/ERCIM); Rogers, Chris (Google, Inc.) – Specification Editor until August 2013; Wei, James (Intel Corporation);

Web Audio API Change Log

See changelog.html.