blob: 1b6af25b3b363411bfb365b1b3b21639584cfa76 [file] [log] [blame]
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into reffy-reports
// (https://github.com/tidoust/reffy-reports)
// Source: Web Audio API (https://webaudio.github.io/web-audio-api/)
enum AudioContextState {
"suspended",
"running",
"closed"
};
callback DecodeErrorCallback = void (DOMException error);
callback DecodeSuccessCallback = void (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;
[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);
};
enum AudioContextLatencyCategory {
"balanced",
"interactive",
"playback"
};
[Exposed=Window,
Constructor (optional AudioContextOptions contextOptions)]
interface AudioContext : BaseAudioContext {
readonly attribute double baseLatency;
readonly attribute double outputLatency;
AudioTimestamp getOutputTimestamp ();
Promise<void> resume ();
Promise<void> suspend ();
Promise<void> close ();
MediaElementAudioSourceNode createMediaElementSource (HTMLMediaElement mediaElement);
MediaStreamAudioSourceNode createMediaStreamSource (MediaStream mediaStream);
MediaStreamTrackAudioSourceNode createMediaStreamTrackSource (MediaStreamTrack mediaStreamTrack);
MediaStreamAudioDestinationNode createMediaStreamDestination ();
};
dictionary AudioContextOptions {
(AudioContextLatencyCategory or double) latencyHint = "interactive";
float sampleRate;
};
dictionary AudioTimestamp {
double contextTime;
DOMHighResTimeStamp performanceTime;
};
[Exposed=Window,
Constructor (OfflineAudioContextOptions contextOptions),
Constructor (unsigned long numberOfChannels, unsigned long length, float sampleRate)]
interface OfflineAudioContext : BaseAudioContext {
Promise<AudioBuffer> startRendering();
Promise<void> resume();
Promise<void> suspend(double suspendTime);
readonly attribute unsigned long length;
attribute EventHandler oncomplete;
};
dictionary OfflineAudioContextOptions {
unsigned long numberOfChannels = 1;
required unsigned long length;
required float sampleRate;
};
[Exposed=Window,
Constructor (DOMString type, OfflineAudioCompletionEventInit eventInitDict)]
interface OfflineAudioCompletionEvent : Event {
readonly attribute AudioBuffer renderedBuffer;
};
dictionary OfflineAudioCompletionEventInit : EventInit {
required AudioBuffer renderedBuffer;
};
[Exposed=Window,
Constructor (AudioBufferOptions options)]
interface AudioBuffer {
readonly attribute float sampleRate;
readonly attribute unsigned long length;
readonly attribute double duration;
readonly attribute unsigned long numberOfChannels;
Float32Array getChannelData (unsigned long channel);
void copyFromChannel (Float32Array destination, unsigned long channelNumber, optional unsigned long bufferOffset = 0);
void copyToChannel (Float32Array source, unsigned long channelNumber, optional unsigned long bufferOffset = 0);
};
dictionary AudioBufferOptions {
unsigned long numberOfChannels = 1;
required unsigned long length;
required float sampleRate;
};
[Exposed=Window]
interface AudioNode : EventTarget {
AudioNode connect (AudioNode destinationNode,
optional unsigned long output = 0,
optional unsigned long input = 0);
void connect (AudioParam destinationParam, optional unsigned long output = 0);
void disconnect ();
void disconnect (unsigned long output);
void disconnect (AudioNode destinationNode);
void disconnect (AudioNode destinationNode, unsigned long output);
void disconnect (AudioNode destinationNode, unsigned long output, unsigned long input);
void disconnect (AudioParam destinationParam);
void 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;
};
enum ChannelCountMode {
"max",
"clamped-max",
"explicit"
};
enum ChannelInterpretation {
"speakers",
"discrete"
};
dictionary AudioNodeOptions {
unsigned long channelCount;
ChannelCountMode channelCountMode;
ChannelInterpretation channelInterpretation;
};
enum AutomationRate {
"a-rate",
"k-rate"
};
[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);
};
[Exposed=Window]
interface AudioScheduledSourceNode : AudioNode {
attribute EventHandler onended;
void start(optional double when = 0);
void stop(optional double when = 0);
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional AnalyserOptions options = {})]
interface AnalyserNode : AudioNode {
void getFloatFrequencyData (Float32Array array);
void getByteFrequencyData (Uint8Array array);
void getFloatTimeDomainData (Float32Array array);
void getByteTimeDomainData (Uint8Array array);
attribute unsigned long fftSize;
readonly attribute unsigned long frequencyBinCount;
attribute double minDecibels;
attribute double maxDecibels;
attribute double smoothingTimeConstant;
};
dictionary AnalyserOptions : AudioNodeOptions {
unsigned long fftSize = 2048;
double maxDecibels = -30;
double minDecibels = -100;
double smoothingTimeConstant = 0.8;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional AudioBufferSourceOptions options = {})]
interface AudioBufferSourceNode : AudioScheduledSourceNode {
attribute AudioBuffer? buffer;
readonly attribute AudioParam playbackRate;
readonly attribute AudioParam detune;
attribute boolean loop;
attribute double loopStart;
attribute double loopEnd;
void start (optional double when = 0,
optional double offset,
optional double duration);
};
dictionary AudioBufferSourceOptions {
AudioBuffer? buffer;
float detune = 0;
boolean loop = false;
double loopEnd = 0;
double loopStart = 0;
float playbackRate = 1;
};
[Exposed=Window]
interface AudioDestinationNode : AudioNode {
readonly attribute unsigned long maxChannelCount;
};
[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;
void setPosition (float x, float y, float z);
void setOrientation (float x, float y, float z, float xUp, float yUp, float zUp);
};
[Exposed=Window,
Constructor (DOMString type, AudioProcessingEventInit eventInitDict)]
interface AudioProcessingEvent : Event {
readonly attribute double playbackTime;
readonly attribute AudioBuffer inputBuffer;
readonly attribute AudioBuffer outputBuffer;
};
dictionary AudioProcessingEventInit : EventInit {
required double playbackTime;
required AudioBuffer inputBuffer;
required AudioBuffer outputBuffer;
};
enum BiquadFilterType {
"lowpass",
"highpass",
"bandpass",
"lowshelf",
"highshelf",
"peaking",
"notch",
"allpass"
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional BiquadFilterOptions options = {})]
interface BiquadFilterNode : AudioNode {
attribute BiquadFilterType type;
readonly attribute AudioParam frequency;
readonly attribute AudioParam detune;
readonly attribute AudioParam Q;
readonly attribute AudioParam gain;
void getFrequencyResponse (Float32Array frequencyHz, Float32Array magResponse, Float32Array phaseResponse);
};
dictionary BiquadFilterOptions : AudioNodeOptions {
BiquadFilterType type = "lowpass";
float Q = 1;
float detune = 0;
float frequency = 350;
float gain = 0;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional ChannelMergerOptions options = {})]
interface ChannelMergerNode : AudioNode {
};
dictionary ChannelMergerOptions : AudioNodeOptions {
unsigned long numberOfInputs = 6;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {})]
interface ChannelSplitterNode : AudioNode {
};
dictionary ChannelSplitterOptions : AudioNodeOptions {
unsigned long numberOfOutputs = 6;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional ConstantSourceOptions options = {})]
interface ConstantSourceNode : AudioScheduledSourceNode {
readonly attribute AudioParam offset;
};
dictionary ConstantSourceOptions {
float offset = 1;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional ConvolverOptions options = {})]
interface ConvolverNode : AudioNode {
attribute AudioBuffer? buffer;
attribute boolean normalize;
};
dictionary ConvolverOptions : AudioNodeOptions {
AudioBuffer? buffer;
boolean disableNormalization = false;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional DelayOptions options = {})]
interface DelayNode : AudioNode {
readonly attribute AudioParam delayTime;
};
dictionary DelayOptions : AudioNodeOptions {
double maxDelayTime = 1;
double delayTime = 0;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional DynamicsCompressorOptions options = {})]
interface DynamicsCompressorNode : AudioNode {
readonly attribute AudioParam threshold;
readonly attribute AudioParam knee;
readonly attribute AudioParam ratio;
readonly attribute float reduction;
readonly attribute AudioParam attack;
readonly attribute AudioParam release;
};
dictionary DynamicsCompressorOptions : AudioNodeOptions {
float attack = 0.003;
float knee = 30;
float ratio = 12;
float release = 0.25;
float threshold = -24;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional GainOptions options = {})]
interface GainNode : AudioNode {
readonly attribute AudioParam gain;
};
dictionary GainOptions : AudioNodeOptions {
float gain = 1.0;
};
[Exposed=Window,
Constructor (BaseAudioContext context, IIRFilterOptions options)]
interface IIRFilterNode : AudioNode {
void getFrequencyResponse (Float32Array frequencyHz, Float32Array magResponse, Float32Array phaseResponse);
};
dictionary IIRFilterOptions : AudioNodeOptions {
required sequence<double> feedforward;
required sequence<double> feedback;
};
[Exposed=Window,
Constructor (AudioContext context, MediaElementAudioSourceOptions options)]
interface MediaElementAudioSourceNode : AudioNode {
[SameObject] readonly attribute HTMLMediaElement mediaElement;
};
dictionary MediaElementAudioSourceOptions {
required HTMLMediaElement mediaElement;
};
[Exposed=Window,
Constructor (AudioContext context, optional AudioNodeOptions options = {})]
interface MediaStreamAudioDestinationNode : AudioNode {
readonly attribute MediaStream stream;
};
[Exposed=Window,
Constructor (AudioContext context, MediaStreamAudioSourceOptions options)]
interface MediaStreamAudioSourceNode : AudioNode {
[SameObject] readonly attribute MediaStream mediaStream;
};
dictionary MediaStreamAudioSourceOptions {
required MediaStream mediaStream;
};
[Exposed=Window,
Constructor (AudioContext context, MediaStreamTrackAudioSourceOptions options)]
interface MediaStreamTrackAudioSourceNode : AudioNode {
};
dictionary MediaStreamTrackAudioSourceOptions {
required MediaStreamTrack mediaStreamTrack;
};
enum OscillatorType {
"sine",
"square",
"sawtooth",
"triangle",
"custom"
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional OscillatorOptions options = {})]
interface OscillatorNode : AudioScheduledSourceNode {
attribute OscillatorType type;
readonly attribute AudioParam frequency;
readonly attribute AudioParam detune;
void setPeriodicWave (PeriodicWave periodicWave);
};
dictionary OscillatorOptions : AudioNodeOptions {
OscillatorType type = "sine";
float frequency = 440;
float detune = 0;
PeriodicWave periodicWave;
};
enum PanningModelType {
"equalpower",
"HRTF"
};
enum DistanceModelType {
"linear",
"inverse",
"exponential"
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional PannerOptions options = {})]
interface PannerNode : AudioNode {
attribute PanningModelType panningModel;
readonly attribute AudioParam positionX;
readonly attribute AudioParam positionY;
readonly attribute AudioParam positionZ;
readonly attribute AudioParam orientationX;
readonly attribute AudioParam orientationY;
readonly attribute AudioParam orientationZ;
attribute DistanceModelType distanceModel;
attribute double refDistance;
attribute double maxDistance;
attribute double rolloffFactor;
attribute double coneInnerAngle;
attribute double coneOuterAngle;
attribute double coneOuterGain;
void setPosition (float x, float y, float z);
void setOrientation (float x, float y, float z);
};
dictionary PannerOptions : AudioNodeOptions {
PanningModelType panningModel = "equalpower";
DistanceModelType distanceModel = "inverse";
float positionX = 0;
float positionY = 0;
float positionZ = 0;
float orientationX = 1;
float orientationY = 0;
float orientationZ = 0;
double refDistance = 1;
double maxDistance = 10000;
double rolloffFactor = 1;
double coneInnerAngle = 360;
double coneOuterAngle = 360;
double coneOuterGain = 0;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional PeriodicWaveOptions options = {})]
interface PeriodicWave {
};
dictionary PeriodicWaveConstraints {
boolean disableNormalization = false;
};
dictionary PeriodicWaveOptions : PeriodicWaveConstraints {
sequence<float> real;
sequence<float> imag;
};
[Exposed=Window]
interface ScriptProcessorNode : AudioNode {
attribute EventHandler onaudioprocess;
readonly attribute long bufferSize;
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional StereoPannerOptions options = {})]
interface StereoPannerNode : AudioNode {
readonly attribute AudioParam pan;
};
dictionary StereoPannerOptions : AudioNodeOptions {
float pan = 0;
};
enum OverSampleType {
"none",
"2x",
"4x"
};
[Exposed=Window,
Constructor (BaseAudioContext context, optional WaveShaperOptions options = {})]
interface WaveShaperNode : AudioNode {
attribute Float32Array? curve;
attribute OverSampleType oversample;
};
dictionary WaveShaperOptions : AudioNodeOptions {
sequence<float> curve;
OverSampleType oversample = "none";
};
[Exposed=Window, SecureContext]
interface AudioWorklet : Worklet {
};
callback AudioWorkletProcessorConstructor = AudioWorkletProcessor (object options);
[Global=(Worklet, AudioWorklet), Exposed=AudioWorklet]
interface AudioWorkletGlobalScope : WorkletGlobalScope {
void registerProcessor (DOMString name, AudioWorkletProcessorConstructor processorCtor);
readonly attribute unsigned long long currentFrame;
readonly attribute double currentTime;
readonly attribute float sampleRate;
};
[Exposed=Window]
interface AudioParamMap {
readonly maplike<DOMString, AudioParam>;
};
[Exposed=Window,
SecureContext,
Constructor (BaseAudioContext context, DOMString name,
optional AudioWorkletNodeOptions options = {})]
interface AudioWorkletNode : AudioNode {
readonly attribute AudioParamMap parameters;
readonly attribute MessagePort port;
attribute EventHandler onprocessorerror;
};
dictionary AudioWorkletNodeOptions : AudioNodeOptions {
unsigned long numberOfInputs = 1;
unsigned long numberOfOutputs = 1;
sequence<unsigned long> outputChannelCount;
record<DOMString, double> parameterData;
object processorOptions;
};
[Exposed=AudioWorklet,
Constructor (optional AudioWorkletNodeOptions options = {})]
interface AudioWorkletProcessor {
readonly attribute MessagePort port;
};
dictionary AudioParamDescriptor {
required DOMString name;
float defaultValue = 0;
float minValue = -3.4028235e38;
float maxValue = 3.4028235e38;
AutomationRate automationRate = "a-rate";
};