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

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

Web Audio API 1.1

これまでの Web 上のオーディオはかなり未発達なもので、ごく最近まで Flash や QuickTime のようなプラグインを通して配信しなくてはなりませんでした。 HTML5 での audio 要素の導入は、基本的なストリーミング・オーディオ再生を可能にする重要なものです。 しかし、より複雑なオーディオアプリケーションを扱うには、それだけではまだ充分に強力ではありません。 洗練された Web ベースのゲームやインタラクティブ・アプリケーションのためには別の解決策が必要とされます。 この仕様では、近年のデスクトップ・オーディオ制作アプリケーションに見られるミキシング、プロセシング、フィルタリング処理に加え、近年のゲームオーディオエンジンに見られるような機能も持たせる事を目標とします。

この API はさまざまな使用例 [webaudio-usecases] を考慮して設計されています。 理想的には すべての ユースケースがスクリプトから制御される最適化された C++ エンジンを使って無理なく実装でき、ブラウザで動作するようにサポートされなくてはなりません。 とは言っても、近年のデスクトップ・オーディオソフトウェアは極めて高度な機能を持ち、それらの一部はこのシステムを使ったとしても構築する事が困難か不可能と考えられます。 Apple 社の Logic Audio がそのようなアプリケーションの 1 つであり、外部 MIDI コントローラー、任意のプラグイン・オーディオエフェクトやシンセサイザー、高度に最適化されたオーディオファイルのディスクへの読み込み/書き出し、密に統合されたタイムストレッチなどなどをサポートしています。 それでもなお、ここで提案するシステムは、音楽に関するものを含めて、かなり複雑なゲームやインタラクティブ・アプリケーションの広い範囲を充分にサポートする事が可能です。 またそれは、WebGL によってもたらされる、より高度なグラフィックスの機能をよく引き立たせる事が可能です。 この API はより高度な機能を後から追加できるように設計されています。

この API は、これらの基本機能をサポートします :

• 単純な、あるいは複雑なミキシング/エフェクト・アーキテクチャーのための モジュラールーティング

• 内部処理に 32 ビット浮動小数を使用した高いダイナミックレンジ

• 非常に高度なリズムの精度を必要とするドラムマシンやシーケンサーなどのアプリケーションのための、低 レイテンシ な サンプル単位の時間精度での音の再生。 これには、エフェクトを 動的に生成 できるようにする事も含まれます

• エンベロープ、フェードイン/フェードアウト、グラニュラーエフェクト、フィルタスイープ、LFO などのためのオーディオパラメータのオートメーション

• 分割や結合など、オーディオストリームのチャンネルに対する柔軟な扱い

• audio または video メディア要素 からのオーディオに対する処理

• getUserMedia() からの MediaStream を使用したライブオーディオ入力に対する処理

• WebRTC との統合

  • MediaStreamTrackAudioSourceNode と [webrtc] を使ってリモート・ピアから受け取ったオーディオの処理

  • 生成または加工されたオーディオストリームの MediaStreamAudioDestinationNode と [webrtc] を使ったリモート・ピアへの送信

• スクリプトでの直接的 なオーディオストリームの合成および加工

• 3D ゲームや没入環境を幅広くサポートする 空間音響 :

  • パンニングモデル: 等価パワー, HRTF, パススルー

  • 距離減衰

  • サウンドコーン

  • 障害物 / 遮蔽物

  • 音源 / リスナー

• 広範囲の線形エフェクト、特に非常に高い品質のルーム・エフェクトに使用できるコンボリューションエンジン。 これによって可能なエフェクトの例を以下に示します:

  • 小さい / 大きい部屋

  • 大聖堂

  • コンサートホール

  • 洞窟

  • トンネル

  • 廊下

  • 森

  • 野外劇場

  • ドア越しの遠くの部屋

  • 極端なフィルタ

  • 風変りな巻き戻し効果

  • 極端なコムフィルタ効果

• ミックス全体の制御やスウィートニングのためのダイナミック・コンプレッション

• 効率的な リアルタイムの時間領域および周波数領域解析 / ミュージックビジュアライザーのサポート

• 効率的な双二次フィルタによる、ローパス、ハイパス、その他一般的なフィルタ

• ディストーションやその他の非線形エフェクトのためのウェーブシェイピング・エフェクト

• オシレーター

モジュラールーティングによって異なる AudioNode オブジェクト同士を任意に接続できます。 それぞれのノードは 入力 および 出力 を持っています。 ソースノード は入力は持たず、ひとつの出力を持ちます。 デスティネーションノード はひとつの入力を持ち、出力は持っていません。 フィルタなどの他のノードはソースとデスティネーションの間に配置することができます。 2 つのオブジェクトが互いに接続し場合、低レベルのストリーム形式の詳細について開発者が煩わされる事なく、適正な処理が行われます。 例えばもしモノラルの音声ストリームがステレオの入力に接続されていても、左右のチャンネルに 適正 にミックスされます。

最も単純な例は、ひとつの音声ソースを出力に直接接続したものです。 すべての接続は単一の AudioDestinationNode を持つ AudioContext 内部で行われます :

この単純なルーティングを図示します。 この例では単一の音を再生しています :

const context = new AudioContext();

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

これはもっと複雑な例で、3 つのソースとコンボリューションリバーブが最終出力段にあるダイナミックコンプレッサーを介して送られます :

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

モジュラールーティングはまた AudioNode の出力を 別の AudioNode の動きを制御する AudioParam パラメータに接続する事もできます。 この場合は、ノードからの出力は入力信号ではなくモジュレーション信号として働きます。

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

定義されているインタフェースは次のとおりです :

• AudioContext インタフェースは、AudioNode 間の接続を表すオーディオ信号グラフを保持します。

• AudioNode インタフェースは、オーディオのソース、オーディオの出力、その間にある処理モジュールを表します。 AudioNode は モジュラー方式 で動的に互いに接続されます。 AudioNode は AudioContext のコンテキスト内に存在します。

• AnalyserNode インタフェースは、ミュージックビジュアライザーやその他の視覚化アプリケーションで使用される AudioNode です。

• AudioBuffer インタフェースは、メモリー内に保持されるオーディオのリソースで使用されます。 これらはワンショットの音、またはもっと長いオーディオクリップを表します。

• AudioBufferSourceNode インタフェースは、AudioBuffer からの音を発生する AudioNode です。

• AudioDestinationNode インタフェースは、AudioNode のサブクラスでオーディオの最終的な出力地点を表します。

• AudioParam インタフェースは、AudioNode の個別の機能、例えば音量などを制御します。

• AudioListener インタフェースは、PannerNode と共に空間音響のために使用されます。

• AudioWorklet インタフェースは、スクリプトでオーディオを直接処理するカスタムノードを作成するファクトリーを表します。

• AudioWorkletGlobalScope インタフェースは、AudioWorkletProcessor の処理スクリプトが実行されるコンテキストです。

• AudioWorkletNode インタフェースは、AudioWorkletProcessor で処理される AudioNode を表します。

• AudioWorkletProcessor インタフェースは、Audio ワーカー内の 1 つのノードのインスタンスを表します。

• BiquadFilterNode インタフェースは、次のような一般的な低次のフィルタの AudioNode です :

  • ローパス

  • ハイパス

  • バンドパス

  • ローシェルフ

  • ハイシェルフ

  • ピーキング

  • ノッチ

  • オールパス

• ChannelMergerNode インタフェースは、複数のオーディオストリームからひとつのオーディオストリームにチャンネルの結合を行う AudioNode です。

• ChannelSplitterNode インタフェースは、ルーティンググラフ内のオーディオストリームの個別のチャンネルにアクセスするために使用される AudioNode です。

• ConstantSourceNode インタフェースは、AudioParam による値のオートメーションが可能な定数値を出力する AudioNode です。

• ConvolverNode インタフェースは、( 例えばコンサートホールでの音のような ) リアルタイム線形エフェクトを加える AudioNode です。

• DelayNode インタフェースは、動的に調整可能な遅延を行う AudioNode です。

• DynamicsCompressorNode インタフェースは、ダイナミクス・コンプレッションのための AudioNode です。

• GainNode インタフェースは、明示的なゲイン制御を行う AudioNode です。

• IIRFilterNode インタフェースは、一般的な IIR フィルタの AudioNode です。

• MediaElementAudioSourceNode インタフェースは、audio、video その他のメディア要素を音源とする AudioNode です。

• MediaStreamAudioSourceNode インタフェースは、ライブオーディオ入力やリモート・ピアから受け取ったような MediaStream を音源とする AudioNode です。

• MediaStreamTrackAudioSourceNode インタフェースは、MediaStreamTrack からのオーディオを音源とする AudioNode です。

• MediaStreamAudioDestinationNode インタフェースは、リモート・ピアに送信する MediaStream を出力先とする AudioNode です。

• PannerNode インタフェースは、3D 空間での空間音響/空間定位のための AudioNode です。

• PeriodicWave インタフェースは、OscillatorNode で使用されるカスタム周期波形を指定するために使用されます。

• OscillatorNode インタフェースは、周期的な波形を発生する AudioNode です。

• StereoPannerNode インタフェースは、ステレオストリームで 入力された信号の equal-power 方式の定位を行う AudioNode です。

• WaveShaperNode インタフェースは、ディストーションやその他微妙なウォーミング効果など、非線形のウェーブシェイピング・エフェクトを加えるための AudioNode です。

また、Web Audio API で既に非推奨とされましたがまだ削除されておらず、置き換えの実装が予定されているいくつかの機能があります :

• ScriptProcessorNode インタフェースは、スクリプトでオーディオを直接生成または処理するための AudioNode です。

• AudioProcessingEvent インタフェースは、ScriptProcessorNode オブジェクトと共に用いられるイベントタイプです。

このインタフェースは AudioNode オブジェクトのセットとそれらの接続を表します。 それによって AudioDestinationNode に任意の信号をルーティングする事を可能にします。 ノードはコンテキストから作成され、お互いに 接続 されます。

BaseAudioContext は直接的にはインスタンス化されず、代わりに AudioContext (リアルタイムレンダリングの場合)と OfflineAudioContext (オフラインレンダリングの場合)が拡張された具体的なインタフェースとなっています。

BaseAudioContext は、初期状態では空のプロミスの順序付きリストである [[pending promises]] という内部スロットを持って作成されます。

各 BaseAudioContext は、固有の メディア要素イベントタスクソース を持っています。 さらに BaseAudioContext には AudioContextState から値を取得する2つのプライベートスロット [[レンダリングスレッドの状態]] と [[制御スレッドの状態]] があり、どちらも最初は "suspended" に設定されています。 さらに符号なし整数のプライベートスロット [[レンダリング量子サイズ]] があります。

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

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

注 : これはホストに関する情報が露出されフィンガープリントに使用される可能性があります。

callback DecodeErrorCallback = undefined (DOMException error);

callback DecodeSuccessCallback = undefined (AudioBuffer decodedData);

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

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

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

audioWorklet, AudioWorklet 型, readonly

[HTML] と AudioWorklet のアルゴリズムにより定義された AudioWorkletProcessor クラスのスクリプトをインポート可能な Worklet オブジェクトへのアクセスを行います。

currentTime, double 型, readonly

コンテキストのレンダリンググラフで最後に処理されたオーディオブロックの最後のサンプルフレームの次のサンプルフレームを秒で表した時刻です。 もしコンテキストのレンダリンググラフがまだオーディオブロックを処理していない場合 currentTime は 0 になります。

currentTime の時間軸で 0 はグラフで処理される最初のブロックの最初のサンプルフレームに対応します。 このシステムの経過時間は BaseAudioContext が生成するオーディオストリームの経過時間に対応し、それはシステム内の他の時計には同期しないかも知れません。 ( OfflineAudioContext では、ストリームはどのデバイスでも能動的に再生されないため、実時間とはまったく違う進み方になります )

Web Audio API のすべてのスケジュールされた時刻は currentTime に対する相対値になります。

BaseAudioContext が "running" 状態にあるとき、この属性の値は単調増加し、レンダリングスレッドにより 1 レンダリング量子 に対応する均一な増分で更新されます。 そのため動作中のコンテキストでは、currentTime はシステムがオーディオブロックを処理するに従って徐々に増加し、常に次に処理されるオーディオブロックの先頭の時刻を表します。 それはまた現在の状態に対する変更が効力を持つ最も早い時刻でもあります。

currentTime は制御スレッドが処理を戻すまでに アトミック に読み取られなくてはなりません ( MUST )。

destination, AudioDestinationNode 型, readonly

AudioDestinationNode は単一の入力を持ち、すべてのオーディオの最終的な出口を表しています。 通常これは実際のオーディオハードウェアを表します。 動作中のすべての AudioNode は直接または間接的にこの destination に接続されます。

listener, AudioListener 型, readonly

AudioListener は 3D 空間音響 で使用されます。

onstatechange, EventHandler 型

AudioContext の状態が変化したとき ( 例えば、対応する Promise がリゾルブされたときなど ) に BaseAudioContext にディスパッチされるイベントのイベントハンドラを設定するために使用されるプロパティです。 このイベントハンドラのイベント型は statechange です。 Event インタフェースを使用するイベントはイベントハンドラにディスパッチされ、AudioContext の状態を直接照会できます。 新たに作成された AudioContext は常に suspended 状態から開始し、状態の変化イベントは異なる状態への遷移の度に発行されます。 このイベントは complete イベントが発生する前に発行されます。

sampleRate, float 型, readonly

BaseAudioContext が扱うオーディオのサンプルレート ( 1 秒あたりのサンプルフレーム数 ) です。 コンテキスト内のすべての AudioNode はこのレートで動作する事を想定しています。 これを想定するため、サンプレートコンバータや " 可変速 " 処理はリアルタイム処理内ではサポートされません。 ナイキスト周波数 はこのサンプルレートの半分の値となります。

state, AudioContextState 型, readonly

BaseAudioContext の現在の状態を表します。 この属性を読み出すと値は [[制御スレッドの状態]] スロットの値を返します。

renderQuantumSize, unsigned long 型, readonly

この属性を読み出すと [[レンダリング量子サイズ]] スロットの値を返します。

createAnalyser()

AnalyserNode の ファクトリーメソッド です。

パラメータなし。

createBiquadFilter()

いくつかの一般的なフィルタタイプに設定可能な 2 次フィルタを表す BiquadFilterNode の ファクトリーメソッド です。

パラメータなし。

createBuffer(numberOfChannels, length, sampleRate)

与えられたサイズの AudioBuffer を作成します。 バッファ内のデータは 0 ( 無音 ) で初期化されます。 もし、引数のどれかが負、0 NotSupportedError 例外を発生します ( MUST )。

BaseAudioContext.createBuffer() メソッドの引数。 パラメータ 型 Null可 省略可 説明 numberOfChannels unsigned long ✘ ✘ バッファが持つチャンネル数を指定します。 実装は少なくとも 32 チャンネルをサポートしなくてはなりません ( MUST )。 length unsigned long ✘ ✘ バッファのサイズをサンプルフレーム数で指定します。 これは少なくとも 1 でなくてはなりません ( MUST )。 sampleRate float ✘ ✘ バッファ内の リニア PCM オーディオデータのサンプルレートを秒あたりのサンプルフレーム数で表します。 実装は少なくとも 8000 から 96000 の範囲をサポートしなくてはなりません ( MUST )。

createBufferSource()

AudioBufferSourceNode の ファクトリーメソッド です。

パラメータなし。

createChannelMerger(numberOfInputs)

チャンネルマージャーを表す ChannelMergerNode の ファクトリーメソッド です。 numberOfInputs が 1 より小さいかサポートするチャンネル数より大きい場合は IndexSizeError 例外を発生します ( MUST )。

createChannelSplitter(numberOfOutputs)

チャンネルスプリッターを表す ChannelSplitterNode の ファクトリーメソッド です。 numberOfOutputs が 1 より小さいかサポートするチャンネル数より大きい場合は、IndexSizeError 例外を発生します ( MUST )。

createConstantSource()

ConstantSourceNode の ファクトリーメソッド です。

パラメータなし。

createConvolver()

ConvolverNode の ファクトリーメソッド です。

パラメータなし。

createDelay(maxDelayTime)

DelayNode の ファクトリーメソッド です。 初期化時のデフォルト遅延時間は 0 秒です。

createDynamicsCompressor()

DynamicsCompressorNode の ファクトリーメソッド です。

パラメータなし。

createGain()

GainNode の ファクトリーメソッド です。

パラメータなし。

createIIRFilter(feedforward, feedback)

createOscillator()

OscillatorNode の ファクトリーメソッド です。

パラメータなし。

createPanner()

PannerNode の ファクトリーメソッド です。

パラメータなし。

createPeriodicWave(real, imag, constraints)

PeriodicWave を作成する ファクトリーメソッド です。

createScriptProcessor(bufferSize, numberOfInputChannels, numberOfOutputChannels)

ScriptProcessorNode の ファクトリーメソッド です。 このメソッドは廃止予定 ( DEPRECATED ) で、AudioWorkletNode で置き換えられる予定です。 スクリプトによるオーディオデータ直接処理のための ScriptProcessorNode を作成します。 bufferSize または numberOfInputChannels または numberOfOutputChannels が範囲外の場合、IndexSizeError 例外を発生します ( MUST )。

numberOfInputChannels と numberOfOutputChannels の両方を 0 にはできません。 この場合、IndexSizeError 例外を発生します ( MUST )。

createStereoPanner()

StereoPannerNode の ファクトリーメソッド です。

パラメータなし。

createWaveShaper()

非線形な歪み効果を表す WaveShaperNode の ファクトリーメソッド です。

パラメータなし。

decodeAudioData(audioData, successCallback, errorCallback)

ArrayBuffer 内にあるオーディオファイルのデータを非同期にデコードします。 ArrayBuffer は、例えば XMLHttpRequest で responseType に "arraybuffer" を指定した場合の response 属性としてロードされます。 オーディオファイルデータは audio 要素でサポートされるどのフォーマットでも構いません。 decodeAudioData() に渡されるバッファは [mimesniff] で説明される手順で判定されるコンテントタイプを持ちます。

この関数の基本的なインタフェースの手段は戻り値の promise ではありますが、歴史的な理由からコールバックのパラメータも提供されています。

ファイルが破損している場合、実装は作成者に警告する事を推奨します。 これは破壊的な変更となるため、スローすることはできません。

注 : 圧縮されたオーディオデータのバイトストリームが破損しているが、デコードは続行可能な場合、実装は開発者ツールなどを通じて作成者に警告することが推奨されます。

decodedData, AudioBuffer 型

デコードしたオーディオデータを保持する AudioBuffer。

error, DOMException 型

デコード中に発生したエラー。

AudioContext は一度作成された後、これ以上再生する音がなくなるまで、あるいはページを移動するまで再生を続けます。

Web Audio API は音源のスケジューリングに fire-and-forget アプローチを取っています。 つまり、音源ノード は、AudioContext のライフタイムの間のひとつひとつの音に対応して作成され、明示的にグラフからの削除は行いません。 これはシリアライゼーション API とは互換性がなく、そのためシリアライズ可能な固定的なノードのセットもありません。

さらに言えば、内部検査のための API があればスクリプトからガベージコレクションの監視が可能になります。

サブクラス、AudioContext と OfflineAudioContext はコストの高いオブジェクトと考えるべきです。 これらのオブジェクトの作成には、高プライオリティのスレッドまたは低レイテンシのシステムオーディオを含み、どちらも消費電力への影響があります。 通常は、1 つのドキュメント内に 1 つ以上の AudioContext を作成する事は不必要です。

BaseAudioContext のサブクラスの作成または再開は、そのコンテキストが システムリソースを取得 する事を含みます。 このためには AudioContext としてはシステムのオーディオストリームを作成する事も必要です。 これらの動作はコンテキストが関連するオーディオグラフから出力の生成を開始する際に処理を戻します。

なお、ユーザーエージェントは実装で定められた最大数の AudioContext を持つ事ができ、それ以上の新しい AudioContext の作成は失敗して、 NotSupportedError 例外を発生します。

suspend および close を使う事で、スレッド、プロセスおよびオーディオストリームを含む システムリソースの解放 を行う事ができます。 BaseAudioContext をサスペンドする事で、実装は一部のリソースを解放して後で resume を呼び出したときに再開できるようにします。 AudioContext のクローズによって、実装はすべてのリソースを解放し、再度使用したり再開したりはできなくなります。

注 :例えば、定期的なコールバックの呼び出しを待つ事やハードウェアが処理可能になるのを待つ事も含みます。

このインタフェースは、その AudioDestinationNode がデバイスへのリアルタイム出力によって直接ユーザーに信号が届くオーディオグラフを表します。 多くの場合、１ つのドキュメントにつき 1 つの AudioContext が使用されます。

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

enum AudioSinkType {
    "none"
};

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

ユーザーエージェントがコンテキストの状態を "suspended" から "running" に移行できる場合、AudioContext が スタート可能 であると言います。 ユーザーエージェントは、AudioContext の 関連するグローバルオブジェクト が スティッキーアクティベーション を持っている場合にのみ許可するために、この最初の遷移を許可しない場合があります。

AudioContext は内部に次のスロットを持っています :

[[suspended by user]]

コンテキストがユーザーのコードによって中断されているかどうかを表すブーリアンフラグです。 初期値は false です。

[[sink ID]]

現在のオーディオ出力デバイスの識別子または情報を表す DOMString または AudioSinkInfo です。 初期値は "" で、デフォルトのオーディオ出力デバイスを意味します。

[[pending resume promises]]

resume() によって作成された保留中の Promise を格納するための順序付きリストです。 最初は空です。

AudioContext(contextOptions)

注 :AudioContext が引数なしで構築され、リソースの取得に失敗した場合、ユーザーエージェントはオーディオ出力デバイスをエミュレートするメカニズムを使用して、オーディオグラフを無音でレンダリングしようとします。

baseLatency, double 型, readonly

これは AudioContext が AudioDestinationNode からオーディオサブシステムにオーディオを渡す処理で発生するレイテンシの秒数を表します。 これには AudioDestinationNode の出力とオーディオハードウェアの間で発生するかも知れないその他の処理による追加のレイテンシは含まれず、特にオーディオグラフ自体に発生するレイテンシは含まれません。

例えばもし、オーディオコンテキストが 44.1 kHz で動作しており、AudioDestinationNode の実装が内部でダブルバッファリングによる レンダリング量子 の出力処理を行う場合、処理のレイテンシは、約 \((2\cdot128)/44100 = 5.805 \mathrm{ ms}\) となります。

outputLatency, double 型, readonly

オーディオ出力処理のレイテンシの秒数の見積もり、つまり UA がホストシステムにバッファを再生を要求した時間から、バッファ内の最初のサンプルが実際にオーディオ出力デバイスで処理される時間までの間隔です。 この後者の時間は、スピーカーやヘッドフォンのような音の信号を発生するデバイスがサンプルの音を発生する時間を指します。

outputLatency 属性の値はプラットフォームと接続されているオーディオ出力デバイスに依存します。 outputLatency 属性の値はコンテキストの実行中や対応するオーディオ出力デバイスの変更時に変化する可能性があります。 正確な同期が必要な場合はこの値を頻繁に問い合わせる事が有用です。

renderCapacity, AudioRenderCapacity 型, readonly

AudioContext に関連付けられた AudioRenderCapacity インスタンスを返します。

sinkId, (DOMString or AudioSinkInfo) 型, readonly

内部スロット [[sink ID]] の値を返します。 この属性は更新時にキャッシュされ、キャッシュされた後は同じオブジェクトを返します。

onsinkchange, EventHandler 型

setSinkId() のイベントハンドラです。 このイベントハンドラのイベントタイプは sinkchange です。 このイベントは、出力デバイスの変更が完了したときに送信されます。

注 : これは、AudioContext の構築時の最初のデバイス選択ではディスパッチされません。 statechange イベントは、初期出力デバイスの準備状況を確認するために使用できます。

onerror, EventHandler 型

AudioContext からディスパッチされた Event のイベントハンドラです。 このハンドラのイベントタイプは error でユーザーエージェントは以下の場合にこのイベントをディスパッチします :

• 選択したオーディオデバイスを初期化してアクティブ化するときにエラーが発生しました。

• コンテキストが running 状態の最中に AudioContext に関連付けられたオーディオ出力デバイスが切断されました。

• オペレーティングシステムがオーディオデバイスの障害を報告しました。

close()

AudioContext をクローズし、使用中の システムリソースを解放 します。 これは AudioContext が作成したすべてのオブジェクトを自動的に開放はしませんが、AudioContext の currentTime の進行を止め、オーディオデータの処理を停止します。

AudioContext がクローズされた場合、AudioContext に接続されているすべての MediaStream と HTMLMediaElement はその出力を無視されます。 つまり、これらはもうスピーカーなどの出力デバイスに出力されなくなります。 より柔軟な挙動のためには、 HTMLMediaElement.captureStream() の使用を検討してください。

注 : AudioContext がクローズされるとき、実装はサスペンドの場合よりも積極的に多くのリソースを解放する事ができます。

パラメータなし。

createMediaElementSource(mediaElement)

指定された HTMLMediaElement から MediaElementAudioSourceNode を作成します。 このメソッドの呼び出しにより、HTMLMediaElement からのオーディオの再生は AudioContext の処理グラフに再ルーティングされるようになります。

createMediaStreamDestination()

MediaStreamAudioDestinationNode を作成します。

パラメータなし。

createMediaStreamSource(mediaStream)

MediaStreamAudioSourceNode を作成します。

createMediaStreamTrackSource(mediaStreamTrack)

MediaStreamTrackAudioSourceNode を作成します。

getOutputTimestamp()

コンテキストのオーディオストリームについて、2 つの関連する位置情報を含む新しい AudioTimestamp インスタンスを返します: contextTime メンバーには、オーディオ出力デバイスによって現在レンダリングされているサンプルフレームの時間 ( つまり出力されているオーディオストリームの位置 ) が含まれます。 これにはコンテキストの currentTime と同じ単位と起点を使用します。 そして performanceTime メンバーには、contextTime に格納された値に対応するサンプルフレームが performance.now() ( [hr-time-3] で説明されています ) と同じ単位および起点で、オーディオ出力デバイスによってレンダリングされる瞬間を推定する時間が含まれます 。

コンテキストのレンダリンググラフがまだオーディオブロックを処理していないときに getOutputTimestamp を呼び出すと、両方のメンバーが 0 である AudioTimestamp インスタンスを返します。

コンテキストのレンダリンググラフがオーディオブロックの処理を開始すると、その currentTime 属性の値は常に getOutputTimestamp メソッドの呼び出しで取得される contextTime 値より大きくなります。

getOutputTimestamp

メソッドから返された値は、コンテキストの時刻のわずかに後になるパフォーマンスの時刻の見積もりを得るのに使用できます:

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

上の例での見積もりの精度は、引数の値が現在の出力オーディオストリームの位置にどれほど近いかによって決まります: つまり与えられた contextTime が timestamp.contextTime に近いほど、得られた推定の精度は良くなります。

注 :コンテキストの currentTime と getOutputTimestamp メソッドの呼び出しから得られた contextTime の値の差は、currentTime が不均一な時間間隔で増加する可能性があるため、信頼できる出力レイテンシの見積もりとみなす事はできず、代わりに outputLatency 属性を使用する必要があります。

パラメータなし。

resume()

AudioContext の currentTime の進行が停止している場合、再開させます。

パラメータなし。

suspend()

AudioContext の currentTime の進行を中断し、デスティネーションで再生するために既に処理を終えた現在のコンテキストの処理ブロックを再生し、その後システムがオーディオハードウェアの占有を解放できるようにします。 これは一般的に、アプリケーションがしばらくの間 AudioContext を必要とせず、一時的に AudioContext に関連付けられた システムリソースを解放 したいことがアプリケーションに分かっているときに役に立ちます。 この promise は、フレームバッファが空のとき ( ハードウェアに渡されたとき )、またはコンテキストがすでに suspended 状態のときは即座に ( 副作用なしで ) リゾルブされます。 コンテキストがクローズされた場合、promise はリジェクトされます。

AudioContext がサスペンドされている間 MediaStream の出力は無視されます。 つまり、メディアストリームのリアルタイム性によって、データは失われます。 HTMLMediaElement も同様に、システムが再開されるまでその出力は無視されます。 AudioWorkletNode および ScriptProcessorNode は、サスペンド中は処理ハンドラの呼び出しが止まりますが、コンテキストがリジュームされると再開します。 AnalyserNode では、ウィンドウ関数の目的そのものにより、データは連続ストリームとみなされます。 つまり、resume()/suspend() によって AnalyserNode のデータストリームに無音は発生しません。 特に、AudioContext がサスペンドされているときに AnalyserNode の関数を繰り返し呼び出した際は、同じデータが返されなければなりません ( MUST )。

パラメータなし。

setSinkId((DOMString or AudioSinkOptions) sinkId)

出力デバイスの識別子を設定します。 このメソッドが呼び出されると、ユーザーエージェントは次の手順を実行しなくてはなりません :

1. sinkId をメソッドの最初の引数とします。

2. sinkId が [[sink ID]] と等しい場合は、Promise を返してすぐにリゾルブしこれらのステップを中止します。

3. validationResult を、sinkId のsink識別子検証の戻り値とします。

4. validationResult が null でない場合は、validationResult でリジェクトされた promise を返し、この手順は中止します。

5. p を新しい promise とします。

6. 処理を開始するために p と sinkId を含む 制御メッセージ を発行します。

7. p を返します。

このアルゴリズムは、sinkId を変更する情報を検証するために使用されます :

AudioContextOptions ディクショナリは AudioContext のユーザー指定のオプションで使用されます。

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

latencyHint, (AudioContextLatencyCategory または double) 型, デフォルト値は "interactive"

オーディオ出力のレイテンシと消費電力の間のトレードオフに影響を与える、再生のタイプを指示します。

latencyHint の値は、AudioContextLatencyCategory から選択する事が推奨されます。 ただし、レイテンシと消費電力をより細かくバランスを取るために、レイテンシの秒数を double 型で指定することもできます。 数値を適切に解釈するのはブラウザの裁量に委ねられています。 実際に使用されるレイテンシは、AudioContext の baseLatency 属性によって与えられます。

sampleRate, float 型

作成される AudioContext の sampleRate をこの値に設定します。 サポートされている値は AudioBuffer のサンプルレートと同じです。 指定されたサンプルレートがサポートされていない場合は NotSupportedError 例外を発生します ( MUST )。

もし sampleRate が指定されていない場合、この AudioContext の出力デバイスが推奨するサンプルレートが使用されます。

sinkId, (DOMString または AudioSinkOptions) 型

オーディオ出力デバイスの識別子または関連情報です。 詳細については sinkId を参照してください。

renderSizeHint, (AudioContextRenderSizeCategory または unsigned long) 型, デフォルト値は "default"

これにより、ユーザーは整数を渡して特定の レンダリング量子サイズ を要求したり、何も渡さないか "default" を渡してデフォルトの 128 フレームを使用したり、"hardware" を指定して適切な レンダリング量子サイズ を選択するようユーザーエージェントに要求したりすることができます。

このヒントは重視されない可能性があります。

AudioSinkOptions ディクショナリは sinkId のオプションを指定するために使用されます。

dictionary AudioSinkOptions {
    required AudioSinkType type;
};

type, AudioSinkType 型

デバイスのタイプを指定する AudioSinkType の値です。

AudioSinkInfo インタフェースは sinkId を介して現在のオーディオ出力デバイスに関する情報を取得するために使用されます。

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

type, AudioSinkType 型, readonly

デバイスのタイプを表す AudioSinkType の値です。

dictionary AudioTimestamp {
    double contextTime;
    DOMHighResTimeStamp performanceTime;
};

contextTime, double 型

BaseAudioContext の currentTime の時間軸内の時刻を表します。

performanceTime, DOMHighResTimeStamp 型

Performance インタフェースの実装における時間軸内の時刻を表します ( [hr-time-3] で説明されています )。

[Exposed=Window]
interface AudioRenderCapacity : EventTarget {
    undefined start(optional AudioRenderCapacityOptions options = {});
        undefined stop();
        attribute EventHandler onupdate;
};

このインタフェースは AudioContext のレンダリングのパフォーマンスに関するメトリクスを取得します。 これを計算するために、レンダラーはシステムレベルのオーディオコールバックごとに 負荷値 を収集します。

onupdate, EventHandler 型

このイベントハンドラのイベントタイプは update です。 イベントハンドラにディスパッチされるイベントは AudioRenderCapacityEvent インタフェースを使用します。

start(options)

メトリクスの収集と分析を開始します。 これにより AudioRenderCapacityOptions で指定された更新間隔で AudioRenderCapacityEvent を使用して AudioRenderCapacity で update という名前の イベントの発行 を繰り返します。

stop()

メトリクスの収集と分析を停止します。 これにより update イベントのディスパッチも停止します。

AudioRenderCapacityOptions ディクショナリを使用して AudioRenderCapacity のオプションの指定で使用されます。

dictionary AudioRenderCapacityOptions {
        double updateInterval = 1;
};

updateInterval, double 型, デフォルト値は 1

AudioRenderCapacityEvent をディスパッチする更新間隔 (秒)。 負荷値 は システムレベルのオーディオコールバック ごとに計算され、指定された間隔の周期で複数の負荷値が収集されます。 たとえば、レンダラーが 48 KHz のサンプルレートで実行され、システムレベルのオーディオコールバックのバッファーサイズが 192 フレームの場合、1 秒間隔で 250 個の負荷値が収集されます。

指定された値が システムレベルのオーディオコールバック の周期よりも小さい場合 NotSupportedError が発生します。

[Exposed=Window]
interface AudioRenderCapacityEvent : Event {
    constructor (DOMString type, optional AudioRenderCapacityEventInit eventInitDict = {});
        readonly attribute double timestamp;
        readonly attribute double averageLoad;
        readonly attribute double peakLoad;
        readonly attribute double underrunRatio;
};

dictionary AudioRenderCapacityEventInit : EventInit {
    double timestamp = 0;
    double averageLoad = 0;
    double peakLoad = 0;
    double underrunRatio = 0;
};

timestamp, double 型, readonly

関連付けられた AudioContext の currentTime に基づくデータ収集期間の開始時刻です。

averageLoad, double 型, readonly

指定された更新間隔で収集された負荷値の平均です。 精度は 1/100 に制限されます。

peakLoad, double 型, readonly

指定された更新間隔で収集された負荷値の最大値です。 精度は 1/100 に制限されます。

underrunRatio, double 型, readonly

バッファアンダーランの数 ( 負荷値 が 1.0 より大きい場合) と、指定された更新間隔での システムレベルのオーディオコールバックの合計数との比率です。

ここで、\(u\) はバッファアンダーランの数、\(N\) は指定された更新間隔での システムレベルのオーディオコールバック の数として、バッファアンダーラン率は次のようになります :

• もし \(u\) = 0. ならば 0.0

• それ以外の場合、\(u/N\) を計算し、最も近い 100 分の 1 単位の切り上げ値

OfflineAudioContext は、レンダリング/ミックスダウンのための特殊なタイプの BaseAudioContext で、( 潜在的には ) リアルタイムよりも高速に動作します。 これはオーディオハードウェアに対してレンダリングせず、可能な限り高速にレンダリングした結果を AudioBuffer に格納して promise を返します。

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

OfflineAudioContext(contextOptions)

OfflineAudioContext(numberOfChannels, length, sampleRate)

OfflineAudioContext は AudioContext.createBuffer と同じ引数で作成できます。 もし引数のどれかが負、0、または範囲外の場合は NotSupportedError 例外を発生します ( MUST )。

OfflineAudioContext は、次の呼び出し

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

が行われたのと同じように作成されます。

length, unsigned long 型, readonly

サンプルフレーム数で表したバッファのサイズです。 これは、コンストラクタの length パラメータの値と同じです。

oncomplete, EventHandler 型

このイベントハンドラのイベントタイプは complete です。 イベントハンドラにディスパッチされるイベントは、OfflineAudioCompletionEventインタフェースを使用します。 これは、OfflineAudioContext で発生する最後のイベントです。

startRendering()

与えられた現在の接続と変化のスケジュールで、オーディオのレンダリングを開始します。

レンダリングされたオーディオデータを取得する主な方法は、promise の戻り値を経由する方法ですが、インスタンスは歴史的な理由により、complete という名前のイベントも発生させます。

パラメータなし。

resume()

OfflineAudioContext がサスペンドされていた場合、その currentTime の進行を再開します。

パラメータなし。

suspend(suspendTime)

指定された時刻にオーディオコンテキストの時間進行の停止をスケジュールし、promise を返します。 これは一般的に、OfflineAudioContext でオーディオグラフを同期して操作する場合に有用です。

サスペンドの最大の精度は レンダリング量子 のサイズであり、指定されたサスペンドの時刻は最も近い レンダリング量子 の境界に丸められることに注意してください。 このため、同じ量子化されたフレーム内で複数のサスペンドをスケジュールすることはできません。 また精度の高いサスペンドを確実に行うには、コンテキストが動作中でない間にスケジューリングを行う必要があります。

これは OfflineAudioContext の作成の際に使用するオプションを指定します。

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

length, unsigned long 型

サンプルフレーム数で表したレンダリングされる AudioBuffer の長さ。

numberOfChannels, unsigned long 型, デフォルト値は 1

この OfflineAudioContext のチャンネル数。

sampleRate, float 型

この OfflineAudioContext のサンプルレート。

renderSizeHint, (AudioContextRenderSizeCategory または unsigned long) 型, デフォルト値は "default"

この OfflineAudioContext の レンダリング量子サイズ に対するヒント。

これは、歴史的な理由から OfflineAudioContext に発行される Event オブジェクトです。

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

renderedBuffer, AudioBuffer 型, readonly

レンダリングしたオーディオデータを保持する AudioBuffer です。

dictionary OfflineAudioCompletionEventInit : EventInit {
    required AudioBuffer renderedBuffer;
};

renderedBuffer, AudioBuffer 型

イベントの renderedBuffer 属性に割り当てる値です。

このインタフェースは、メモリー上にあるオーディオデータを表します。 これは 1 つ以上のチャンネルを持ち、それぞれのチャンネルは 32 ビット浮動小数で リニア PCMを表し、公称範囲は \([-1,1]\) ですが、値はこの範囲に限定されません。 典型的には PCM データの長さはかなり短い ( 通常は 1 分未満 ) と想定されています。 音楽サウンドトラックなどのより長いサウンドの場合は、audio 要素と MediaElementAudioSourceNode によるストリーミングを使用するべきです。

AudioBuffer は、1 つ以上の AudioContext によって使用され、OfflineAudioContext と AudioContext の間で共有する事もできます。

AudioBuffer には 4 つの内部スロットがあります：

[[number of channels]]

この AudioBuffer のオーディオチャンネルの数、符号なし unsigned long 型です。

[[length]]

この AudioBuffer の各チャンネルの長さ、unsigned long 型です。

[[sample rate]]

Hz で表した AudioBuffer のサンプルレート、float 型です。

[[internal data]]

オーディオのサンプルデータを保持する データブロック です。

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

AudioBuffer(options)

duration, double 型, readonly

秒数で表した PCM オーディオデータの長さです。

これは AudioBuffer の [[sample rate]] と [[length]] から計算され、[[length]] を [[sample rate]] で割る事で求められます。

length, unsigned long 型, readonly

サンプルフレーム数で表した PCM オーディオデータの長さです。 これは [[length]] の値を返さなければなりません ( MUST )。

numberOfChannels, unsigned long 型, readonly

個別のオーディオチャンネルの数です。 これは [[number of channels]] の値を返さなければなりません ( MUST )。

sampleRate, float 型, readonly

サンプル / 秒で表した PCM オーディオデータのサンプルレートです。 これは、[[sample rate]] の値を返さなければなりません ( MUST )。

copyFromChannel(destination, channelNumber, bufferOffset)

copyFromChannel() メソッドは、AudioBuffer の指定されたチャンネルからサンプルを destination の配列にコピーします。

buffer を フレーム数 \(N_b\) の AudioBuffer とし、\(N_f\) を destination 配列の要素数とし、\(k\) を bufferOffset の値とします。 このとき、buffer から destination にコピーされるフレームの数は \(\max(0, \min(N_b - k, N_f))\) となります。 もしこれが \(N_f\) より小さい場合、destination の残りの要素は変更されません。

copyToChannel(source, channelNumber, bufferOffset)

copyToChannel() メソッドは、source 配列から AudioBuffer の指定されたチャンネルにサンプルをコピーします。

もし、source がバッファにコピーできない場合は UnknownError を発生する事があります。

buffer を フレーム数 \(N_b\)の AudioBuffer とし \(N_f\) を source 配列の要素数とし、\(k\) を bufferOffset の値とします。 このとき、source から buffer にコピーされるフレームの数は \(\max(0, \min(N_b - k, N_f))\) となります。 これが \(N_f\) より小さい場合、buffer の残りの要素は変更されません。

getChannelData(channel)

コンテンツの取得 に記述されているルールに従って、[[internal data]] に格納されているバイトへの 書き込み または新しい Float32Array に 読み出し する事ができます。

もし、[[internal data]] または新しい Float32Array の作成ができなかった場合は、UnknownError を発生する事があります。

注 : copyToChannel() と copyFromChannel() メソッドはより大きな配列のビューである Float32Array を渡す事で配列の一部だけを埋めるのに使用できます。 AudioBuffer のチャンネルからデータを読み取って塊りとして処理する場合、不要なメモリの割り当てとコピーを回避するため、getChannelData() を呼び出して結果の配列にアクセスするよりも、copyFromChannel() をお勧めします。

APIの実装により AudioBuffer の内容が必要になったとき、AudioBuffer の内容の取得 という内部処理が起動されます。 この処理は呼び出し元に変更不能なチャンネルデータを返します。

AudioBuffer の内容の取得 処理は、次の場合に呼び出されます :

• AudioBufferSourceNode.start が呼び出されると、ノードの buffer の 内容の取得 を行います。 この処理が失敗した場合は何も再生されません。

• AudioBufferSourceNode.start があらかじめ呼び出されている状態で、AudioBufferSourceNode の buffer が設定されたとき、その設定処理が AudioBuffer の 内容の取得 を行います。 この処理が失敗した場合、何も再生されません。

• ConvolverNode の buffer がある AudioBuffer に設定された時、その AudioBuffer の 内容の取得 が行われます。

• AudioProcessingEvent のディスパッチが完了すると、その outputBuffer の 内容の取得 が行われます。

注 :これは copyToChannel() は現在 AudioNode が AudioBuffer の 内容を取得 して使用中の AudioBuffer の内容を変更するためには使えない事を意味します。 AudioNode は以前に取得したデータを使い続けます。

これは AudioBuffer の作成に使用するオプションを指定します。 length と sampleRate メンバーは必須です。

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

このディクショナリのメンバーが取れる値には制約があります。 createBuffer() を参照してください。

length, unsigned long 型

サンプルフレーム数で表されるバッファの長さです。 制約については length を参照してください。

numberOfChannels, unsigned long 型, デフォルト値は 1

バッファのチャンネル数です。 制約については numberOfChannels を参照してください。

sampleRate, float 型

Hz で表されるバッファのサンプルレートです。 制約については sampleRate を参照してください。

AudioNode は AudioContext の構成ブロックです。 このインタフェースは、音源、音の出力先、および中間の処理モジュールを表しています。 これらのモジュールは互いに接続されて、音をオーディオハードウェアに出力するための 処理グラフ を形成します。 それぞれのノードは 入力 や 出力 を持つ事ができます。 ソースノード は入力を持たず、単一の出力を持ちます。 フィルタのようなほとんどの処理ノードは、1 つの入力と 1 つの出力を持ちます。 それぞれのタイプの AudioNode はどのようにオーディオを処理したり合成するのかの詳細が異なっています。 しかし一般的に AudioNode は ( 持っていれば ) 入力を処理し、( 持っていれば ) その出力にオーディオ信号を送り出します。

それぞれの出力は 1 つ以上のチャンネルを持っています。 正確なチャンネル数はそれぞれの AudioNode の詳細に依存します。

出力は 1 つ以上の AudioNode の入力に接続でき、つまり ファンアウト がサポートされています。 入力は初期状態では接続されていません。 しかし、1 つ以上の AudioNode の出力から接続する事ができ、即ち、ファンイン がサポートされています。 AudioNode の出力を AudioNode の入力に接続するため connect() メソッドが呼ばれたとき、それをその入力への 接続 と呼びます。

各 AudioNode の 入力 はその時々で特定のチャンネル数を持ちます。 この数はその入力への 接続 によって変化します。 もし入力が接続を持っていない場合、チャンネル数は 1 で無音となります。

AudioNode は 各々の 入力 について、その入力へのすべての接続のミキシングを行います。 この詳細な基準となる要件については § 4 チャンネルのアップミックスとダウンミックス セクションを参照してください。

AudioNode の入力および内部の処理は、そのノードが出力を接続されているか、またそれらの出力が AudioContext の AudioDestinationNode に最終的に到達しているかどうかに関わらず、AudioContext の時刻を踏まえて継続的に行われます。

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

AudioNode の作成には 2 つの方法があります: 特定のインタフェースのコンストラクタを使用する方法、と BaseAudioContext または AudioContext の ファクトリーメソッド を使用する方法です。

AudioNode のコンストラクタの最初の引数として渡される BaseAudioContext は、作成される AudioNode が 関連する BaseAudioContext と呼ばれます。 同様に、ファクトリーメソッドを使用する場合、AudioNode の 関連する BaseAudioContext は このファクトリーメソッドが呼び出される BaseAudioContext です。

上の

の呼び出しにより、特定のタイプ

の新しい

を作成するには、次の手順を実行します :

1. node を型 n の新しいオブジェクトとします。

2. option を、このファクトリーメソッドに 対応する インタフェースに 関連付け られた型のディクショナリとします。

3. ファクトリーメソッドに渡される各パラメータについて、option 内の名前が一致するディクショナリメンバーをこのパラメータの値に設定します。

4. node の作成のために c と option を引数として n の コンストラクタを呼び出します。

5. node を返します。

ファクトリーメソッドに 関連するインタフェース は、このメソッドから返されるオブジェクトのインタフェースです。 インタフェースに 関連するオプションオブジェクト は、このインタフェースのコンストラクタに渡すことができるオプションオブジェクトです。

AudioNode は [DOM] で説明されているように EventTarget です。 つまり、他の EventTarget がイベントを受け入れるのと同じ方法で、イベントを AudioNode にディスパッチすることができます。

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

ChannelCountMode は、ノードの channelCount および channelInterpretation の値と組み合わせて、ノードへの入力をどのようにミックスするかを制御する computedNumberOfChannels を決定するために使用されます。 computedNumberOfChannels は次のように決定されます。 ミックスがどのように行われるかの詳細については、§ 4 チャンネルのアップミックスとダウンミックス を参照してください。

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

AudioNode は テールタイム を持つことができます。 これは AudioNode に無音が供給されている場合でも、出力が無音では無い可能性があることを意味します。

AudioNode は過去の入力が将来の出力に影響するような内部処理状態を持っている場合、非ゼロのテールタイムを持っています。 AudioNode は、入力が音のある状態から無音に移行した後でも、計算されたテールタイムの間、音を出力し続ける場合があります。

AudioNode は次のいずれかの条件が満たされている場合、レンダリング量子 の間 アクティブに処理 を続けます。

• AudioScheduledSourceNode は現在のレンダリング量子の少なくとも一部で 再生 されている場合にのみ アクティブに処理 されます。

• MediaElementAudioSourceNode はその mediaElement が現在のレンダリング量子の少なくとも一部で再生されている場合にのみ アクティブに処理 されます。

• MediaStreamAudioSourceNode または MediaStreamTrackAudioSourceNode は関連付けられている MediaStreamTrack オブジェクトの readyState 属性が "live" で、muted 属性が false で、enabled 属性が true である場合に アクティブに処理 されます。

• 循環の中に入っている DelayNode は現在の レンダリング量子 の出力サンプルの絶対値が \( 2^{-126} \) 以上の場合にのみ アクティブに処理 されます。

• ScriptProcessorNode は、その入力または出力が接続されている場合に アクティブに処理 されます。

• AudioWorkletNode は AudioWorkletProcessor の [[callable process]] が true を返して、その active source フラグが true であるか、入力のどれかに接続されている AudioNode が アクティブに処理 している場合に アクティブに処理 されます。

• 他のすべての AudioNode は、その入力のどれかに接続された AudioNode が アクティブに処理 を行っているのであれば アクティブな処理 を開始し、他の アクティブに処理 を行っている AudioNode から受け取った入力が出力に影響を与えなくなったときに アクティブな処理 を停止します。

注 :これは AudioNode が テールタイム を持つ事を考慮に入れます。

アクティブに処理 を行っていない AudioNode は 1 チャンネルの無音を出力します。

channelCount, unsigned long 型

channelCount はノードへの入力の接続におけるアップミックスおよびダウンミックスの際に使用されるチャンネル数です。 値が別途定められている特定のノードを除いて、デフォルトは 2 です。 この属性は入力を持たないノードでは意味を持ちません。 もしこの値が 0、あるいは実装のチャンネル数の最大値より大きい値にセットされた場合、NotSupportedError 例外を発生します ( MUST )。

さらに、一部のノードではこれに加えて、設定可能な チャンネル数の制約 があります :

AudioDestinationNode

この動作は、接続先のデスティネーションノードが AudioContext か OfflineAudioContext かによって異なります :

AudioContext

チャンネル数は 1 から maxChannelCount の間でなければなりません ( MUST )。 この範囲外の値を設定しようとすると、IndexSizeError 例外を発生します ( MUST )。

OfflineAudioContext

チャンネル数を変更することはできません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

AudioWorkletNode

§ 1.32.4.3.2 AudioWorkletNodeOptions のチャンネル構成 を参照してください。

ChannelMergerNode

チャンネル数を変更することはできません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

ChannelSplitterNode

チャンネル数を変更することはできません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

ConvolverNode

チャンネル数は 2 より大きくできません。 2 より大きい値を設定しようとすると NotSupportedError 例外を発生します ( MUST )。

DynamicsCompressorNode

チャンネル数は 2 より大きい値にはできません。 2 より大きい値に変更しようとすると NotSupportedError 例外を発生します ( MUST )。

PannerNode

チャンネル数は 2 より大きくすることはできません。 2 より大きな値に変更しようとすると NotSupportedError 例外を発生します ( MUST )。

ScriptProcessorNode

チャンネル数は変更することができません。 変更しようとすると NotSupportedError 例外を発生します ( MUST )。

StereoPannerNode

チャンネル数は 2 より大きくすることはできません。 2 より大きな値に変更しようとすると NotSupportedError 例外を発生します ( MUST )。

この属性の詳細については、§ 4 チャンネルのアップミックスとダウンミックス を参照してください。

channelCountMode, ChannelCountMode 型

channelCountMode は、ノードの入力への接続をアップミックスおよびダウンミックスするときに、チャンネルがどのようにカウントされるかを決定します。 デフォルト値は "max" です。 この属性は、入力のないノードには影響しません。

さらに、一部のノードでは、チャンネル数モードが取れる値について channelCountMode の制約 があります :

AudioDestinationNode

AudioDestinationNode が OfflineAudioContext の destination ノードである場合、チャンネル数モードは変更できません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

ChannelMergerNode

チャンネル数モードは "explicit" から変更できません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

ChannelSplitterNode

チャンネル数モードは "explicit" から変更できません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

ConvolverNode

チャンネル数モードは "max" に設定する事はできません。 値を "max" に設定しようとすると NotSupportedError 例外を発生します ( MUST )。

DynamicsCompressorNode

チャンネル数モードは "max" に設定する事はできません。 値を "max" に設定しようとすると NotSupportedError 例外を発生します ( MUST )。

PannerNode

チャンネル数モードは "max" に設定する事はできません。 値を "max" に設定しようとすると NotSupportedError 例外を発生します ( MUST )。

ScriptProcessorNode

チャンネル数モードは "explicit" から変更できません。 値を変更しようとすると NotSupportedError 例外を発生します ( MUST )。

StereoPannerNode

チャンネル数モードは "max" に設定する事はできません。 値を "max" に設定しようとすると NotSupportedError 例外を発生します ( MUST )。

この属性の詳細については、§ 4 チャンネルのアップミックスとダウンミックス を参照してください。

channelInterpretation, ChannelInterpretation 型

channelInterpretation は、ノードの入力への接続をアップミックスまたはダウンミックスするときに、個々のチャンネルをどのように扱うかを決定します。 デフォルト値は "speakers" です。 この属性は、入力のないノードには影響しません。

さらに、一部のノードでは、チャンネルの解釈として取れる値に追加の channelInterpretation の制約 があります :

ChannelSplitterNode

チャンネルの解釈は "discrete" から変更することはできません。 値を変更しようとすると InvalidStateError 例外を発生します ( MUST )。

この属性の詳細については、§ 4 チャンネルのアップミックスとダウンミックス を参照してください。

context, BaseAudioContext 型, readonly

この AudioNode を所有する BaseAudioContext です。

numberOfInputs, unsigned long 型, readonly

この AudioNode の入力の数です。 ソースノード ではこれは 0 になります。 この属性は多くの AudioNode のタイプであらかじめ決められていますが、ChannelMergerNode や AudioWorkletNode のようないくつかの AudioNode では入力の数は可変です。

numberOfOutputs, unsigned long 型, readonly

この AudioNode から出る出力の数です。 この属性はいくつかの AudioNode ではあらかじめ決められた値ですが、ChannelSplitterNode や AudioWorkletNode などでは可変になります。

connect(destinationNode, output, input)

あるノードの特定の出力から別のノードの特定の入力への接続は 1 つだけ存在できます。 同じ端子間の複数回の接続は無視されます。

例えば

:

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

は次のものと同じ効果になります。

nodeA.connect(nodeB);

このメソッドは、destination の AudioNode オブジェクトを返します。

connect(destinationParam, output)

AudioNode を AudioParam に接続し、パラメータの値を a-rate の信号で制御します。

connect() を複数回呼び出す事で、1 つの AudioNode の出力を 1 つ以上の AudioParam に接続する事が可能です。 即ち "ファンアウト" がサポートされています。

connect() を複数回呼び出す事で、1 つ以上の AudioNode を 1 つの AudioParam に接続する事が可能です。 即ち "ファンイン" がサポートされています。

AudioParam はそれに接続されているすべての AudioNode の出力からレンダリングされたオーディオデータを取り出し、それがモノラルでなければ、ダウンミックスによって モノラルに変換 します。 そして接続されている各出力をミックスし、さらに最終的にパラメータが持っているタイムラインの変化スケジュールを含む 固有値 ( AudioParam に何も接続されていない状態での value ) とミックスします。

モノラルへのダウンミックスは、channelCount = 1、channelCountMode = "explicit"、および channelInterpretation = "speakers" の AudioNode のダウンミックスに相当します。

特定のノードの出力と特定の AudioParam の間の接続は 1 つのみ存在できます。 同じ終端点を持つ複数の接続は無視されます。

例えば :

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

は次のものと同じ効果になります。

nodeA.connect(param);

disconnect()

AudioNode から出るすべての接続を切断します。

パラメータなし。

disconnect(output)

AudioNode の 1 つの出力から他の AudioNode または AudioParam オブジェクトへの接続をすべて切断します。

disconnect(destinationNode)

AudioNode のすべての出力から特定の接続先となる AudioNode に繋がる接続を切断します。

disconnect(destinationNode, output)

AudioNode の特定の出力からある接続先 AudioNode のすべての入力への接続を切断します。

disconnect(destinationNode, output, input)

AudioNode の特定の出力から 接続先 AudioNode の特定の入力への接続を切断します。

disconnect(destinationParam)

特定の接続先 AudioParam に繋がる AudioNode のすべての出力を切断します。 この操作によって、この AudioNode からパラメータ値の計算への寄与は 0 となります。 パラメータの固有値はこの操作に影響されません。

disconnect(destinationParam, output)

AudioNode の特定の出力から特定の AudioParam への接続を切断します。 この操作によって、この AudioNode からパラメータ値の計算への寄与は 0 となります。 パラメータの固有値はこの操作に影響されません。

これは、すべての AudioNode の生成の際に使用できるオプションを指定します。 すべてのメンバーはオプションです。 ただし、それぞれのノードで使われる値は、実際のノードに依存します。

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

channelCount, unsigned long 型

channelCount 属性に要求するチャンネル数です。

channelCountMode, ChannelCountMode 型

channelCountMode 属性に要求するモードです。

channelInterpretation, ChannelInterpretation 型

channelInterpretation 属性に要求するモードです。

AudioParam は AudioNode の例えば音量のような個別の機能をコントロールします。 パラメータは value 属性を使って特定の値に即時にセットする事ができます。 あるいは ( AudioContext の currentTime 属性の時間軸で ) 非常に高い時間精度で値の変化のスケジュールを組む事ができ、エンベロープ、音量のフェード、LFO、フィルタスイープ、グレイン窓、などに応用する事ができます。 このような方法で任意のタイムラインベースのオートメーション曲線をすべての AudioParam に対して設定する事が可能です。 またさらに、AudioNode からの出力の音声信号を AudioParam に接続する事ができ、個別に持っているパラメータの 固有値 に加算する事ができます。

いくつかの合成や処理の AudioNode は、オーディオサンプル単位で反映されなくてはならない ( MUST ) AudioParam 型の属性を持っています。 その他の AudioParam はサンプル単位の精度は重要ではなく、その値の変化はより粗く取り込まれます。 各 AudioParam は a-rate パラメータつまりサンプル単位で反映される ( MUST )か、それ以外の k-rate パラメータかが指定されます。

実装はそれぞれの AudioNode について、1 レンダリング量子 ごとのブロック単位の処理を行わなくてはなりません ( MUST )。

それぞれの レンダリング量子 に対して、k-rate パラメータは最初のサンプルのタイミングで取り込まれ、その値はブロック全体に対して使用されなくてはなりません ( MUST )。 a-rate パラメータはブロック内のサンプルフレームごとに取り込まれなくてはなりません ( MUST )。 AudioParam によっては、automationRate 属性を "a-rate" または "k-rate" のいずれかに設定することによって、レートを制御できます。 詳細については、個々の AudioParam の説明を参照してください。

各 AudioParam は minValue および maxValue 属性を持っており、それがパラメータの 単純な公称範囲 となっています。 実際のパラメータの値は \([\mathrm{minValue}, \mathrm{maxValue}]\) の範囲に制限されます。 詳細は、§ 1.6.3 値の計算 を参照してください。

多くの AudioParam では、minValue と maxValue は可能な最大限の範囲に設定されています。 この場合、maxValue は、最も正の単精度浮動小数点値 である 3.4028235e38 となります。 ( ただし、JavaScript では IEEE-754 倍精度浮動小数点値のみをサポートするため、これは 3.4028234663852886e38 と書かなくてはなりません ) 同様に、minValue は 最も負の単精度浮動小数点値、つまり 最も正の単精度浮動小数点値 の符号を負にしたもの: -3.4028235e38 となります。 ( 同様に、これは JavaScript では -3.4028234663852886e38 として記述する必要があります )。

AudioParam は、0 個以上の オートメーションイベント のリストを保持しています。 各オートメーションイベントは、AudioContext の currentTime 属性の時間軸における オートメーションイベント時刻 に関連して、特定の時間範囲にわたるパラメータ値の変更を指定します。 オートメーションイベントのリストは、オートメーションイベント時刻の昇順で管理されます。

オートメーションイベントの振る舞いは、AudioContext の現在の時刻とこのイベントのオートメーションイベント時刻とリスト内に隣接するイベントの関数になります。 以下の オートメーションメソッド は、そのメソッドに固有のタイプの新しいイベントをイベントリストに追加し、変更します :

• setValueAtTime() - SetValue

• linearRampToValueAtTime() - LinearRampToValue

• exponentialRampToValueAtTime() - ExponentialRampToValue

• setTargetAtTime() - SetTarget

• setValueCurveAtTime() - SetValueCurve

これらのメソッドが呼ばれるとき、次の規則が適用されます :

• オートメーションイベント時刻 は、使われるサンプルレートに対して量子化されません。 カーブと傾斜を決定する式では、イベントをスケジューリングするときに与えられた正確な数値的な時刻を使用されます。

• これらのイベントが、リストの中で既に 1 つまたは複数のイベントが存在する時刻に追加された場合、そのイベントの後で、時刻がより後ろのイベントの前に追加されます。

• もし setValueCurveAtTime() が時刻 \(T\) と持続時間 \(D\) を指定して呼ばれたとき、\(T\) よりも厳密に後ろで \(T + D\) よりも厳密に手前に何らかのイベントが既に存在している場合、NotSupportedError 例外を発生します ( MUST )。 言い換えれば、他のイベントの時刻を含んだ期間のカーブをスケジュールする事はできませんが、他のイベントと正確に同じ時刻の値をスケジュールすることは問題ありません。

• 同様に、時刻 \(T\) と 持続時間 \(D\) で示されるカーブの期間 \([T, T+D)\) に含まれる時刻を指定して何らかの オートメーションメソッド を呼んだ場合、NotSupportedError 例外を発生します ( MUST )。

注 :AudioParam の属性は、value 属性を除いて、読み取り専用です。

AudioParam のオートメーションレートは、automationRate 属性を次のいずれかの値で設定して選択できます。 ただし、一部の AudioParam では、オートメーションレートを変更できるかどうかについて制約があります。

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

各 AudioParam には内部スロット [[current value]] があり、AudioParam の defaultValue に初期設定されています。

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

automationRate, AutomationRate 型

AudioParam のオートメーションの速度です。 デフォルト値は実際の AudioParam に依存します。 デフォルト値についてはそれぞれの AudioParam の説明を参照してください。

いくつかのノードには、次のような追加の オートメーション速度の制約 があります :

AudioBufferSourceNode

AudioParam の playbackRate と detune は "k-rate" でなくてはなりません ( MUST )。 速度が "a-rate" に変更された場合は、InvalidStateError が発生します。

DynamicsCompressorNode

AudioParam の threshold 、knee 、ratio 、attack 、および release は、"k-rate" でなければなりません ( MUST )。 速度が "a-rate" に変更された場合、InvalidStateError が発生します。

PannerNode

panningModel が "HRTF" の場合、PannerNode のすべての AudioParam に対する automationRate の設定は無視されます。 同様に、AudioListener のすべての AudioParam の automationRate の設定は無視されます。 この場合、AudioParam は、automationRate が "k-rate" に設定されているかのように動作します。

defaultValue, float 型, readonly

value 属性の初期値です。

maxValue, float 型, readonly

パラメータが取ることができる名目上の最大値です。 minValue と組み合わせて、これはこのパラメータの 公称範囲 となります。

minValue, float 型, readonly

パラメータが取ることができる名目上の最小値です。 maxValue と組み合わせて、これはこのパラメータの 公称範囲 となります。

value, float 型

パラメータの浮動小数点の値です。 この属性の初期値は defaultValue となります。

この属性を読み取ると、[[current value]] スロットの内容が返されます。 返される値のアルゴリズムについては § 1.6.3 値の計算 を参照してください。

この属性を設定すると、要求された値を [[current value]] スロットに割り当て、現在の AudioContext の currentTime と [[current value]] を使って setValueAtTime() メソッドを呼び出す効果があります。 setValueAtTime() で発生する例外がこの属性を設定する事でも発生する事があります。

cancelAndHoldAtTime(cancelTime)

これは cancelTime と同じかそれ以降の時刻のスケジュールされたすべてのパラメータの変化をキャンセルするという点で cancelScheduledValues() と似ています。 しかしそれに加えて cancelTime の時点でのオートメーション値が、他のオートメーションイベントが起こるまで、保持されます。

オートメーションが動作中に cancelAndHoldAtTime() を呼び出してから cancelTime に達するまでの任意の時間の cancelAndHoldAtTime() に対するタイムラインの動作は非常に複雑です。 それで cancelAndHoldAtTime() の動作は次のアルゴリズムで定義されます。

\(t_c\) を

cancelTime

の値とします。 そして、

1. 時刻 \(t_1\) におけるイベントを ( 存在すれば ) \(E_1\) とし、\(t_1\) が \(t_1 \le t_c\) を満たす最大の数であるとします。

2. 時間 \(t_2\) におけるイベントを ( 存在すれば ) \(E_2\) とし、\(t_2\) が \(t_c \lt t_2\) を満たす最小の数であるとします。

3. もし \(E_2\) が存在すれば :

   1. もし、\(E_2\) が linear または exponential 型の傾斜の場合、

      1. 実質的に \(E_2\) を書き換えて、時刻 \(t_c\) に終了し、最終値が元の傾斜の \(t_c\) の時点の値である同じ種類の傾斜とします。

      2. ステップ 5. に行きます。

   2. そうでなければ ステップ 4. に行きます。

4. もし \(E_1\) が存在すれば :

   1. もし \(E_1\) が setTarget イベントの場合、

      1. 時刻 \(t_c\) に setValueAtTime イベントを暗黙的に挿入し、setTarget が時刻 \(t_c\) に持つであろう値とします。

      2. ステップ 5. に行きます。

   2. もし \(E_1\) が setValueCurve で、開始時刻が \(t_3\)、持続時間が \(d\) の場合

      1. もし \(t_c \gt t_3 + d\) ならば ステップ 5. に行きます。

      2. そうでなければ、

         1. 実質的にこのイベントを、開始時刻が \(t_3\)、新しい持続時間が \(t_c-t_3\) の setValueCurve イベントで置き換えます。 しかしながら、これは単なる置き換えではありません。 このオートメーションは、オリジナルと同じ出力を生成するために留意しなくてはならず ( MUST )、ただ異なる持続時間を使用して計算された出力ではありません。 ( これだと、値の曲線を少し違う方法でサンプリングして、異なる結果を生じることになります )。

         2. ステップ 5. に行きます。

5. 時刻 \(t_c\) より後ろのすべてのイベントを削除します。

イベントが追加されない場合は、cancelAndHoldAtTime() の後のオートメーション値は、元のタイムラインが時刻 \(t_c\) に持つ定数値となります。

cancelScheduledValues(cancelTime)

cancelTime と同じか後ろの時刻にスケジュールされたすべてのパラメータ変化を取り消します。 スケジュールされたパラメータ変化を取り消すという事は、スケジュールされたイベントをイベントリストから削除することを意味します。 オートメーションイベントの時刻 が cancelTime 未満の現在動作中のオートメーションも取り消され、( そのオートメーション以前の ) 直前の値が直ちに復元されるため、このような取り消しは不連続を引き起こす可能性があります。 cancelAndHoldAtTime() によってスケジュールされたすべてのホールド値で、cancelTime の後ろにホールドの時刻が発生した場合にもまた削除されます。

setValueCurveAtTime() の場合、\(T_0\) と \(T_D\) は それぞれこのイベントの startTime と duration とします。 そして cancelTime が \([T_0, T_0 + T_D]\) の範囲内にあるならば、イベントがタイムラインから削除されます。

exponentialRampToValueAtTime(value, endTime)

前にスケジュールされているバラメーター値から指定された値まで、指数的に連続して値を変化させる事をスケジュールします。 フィルタの周波数や再生スピードなどのパラメータは人間の聴覚特性のため、指数的変化が適しています。

時間範囲 \(T_0 \leq t < T_1\) ( ここで \(T_0\) は前のイベントの時刻で \(T_1\) はこのメソッドに渡された endTime パラメータです ) に対して次のように計算されます :

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

ここで \(V_0\) は時刻 \(T_0\) での値、\(V_1\) はこのメソッドに渡された value パラメータです。 もし \(V_0\) と \(V_1\)が、逆の符号を持つか \(V_0\) が 0 ならば、\(T_0 \le t \lt T_1\) に対して \(v(t) = V_0\) となります。

これはまた、0 に向かう指数カーブが不可能である事も示しています。 setTargetAtTime() で適当な時間定数を選択する事で良い近似を得る事ができます。

もしこの ExponentialRampToValue イベント以降のイベントがない場合 \(t \geq T_1\) に対して \(v(t) = V_1\) となります

もしこのイベントより前にイベントが存在しない場合、指数カーブは setValueAtTime(value, currentTime) が呼び出されたかのように動作します。 ここで value は属性の現在の値で currentTime は exponentialRampToValueAtTime() が呼び出された時刻のコンテキストの currentTime です。

もし、前のイベントが SetTarget イベントの場合、\(T_0\) と \(V_0\) は SetTarget オートメーションの現在の時刻と値から選択されます。 SetTarget イベントがまだ開始されていない場合、\(T_0\) はイベントの開始時刻であり、\(V_0\) は SetTarget イベントの開始直前の値です。 この場合 ExponentialRampToValue イベントは実質的に SetTarget イベントを置き換えます。 もし SetTarget イベントが既に開始されている場合、\(T_0\) は現在のコンテキストの時刻であり、\(V_0\) は時刻 \(T_0\) での現在の SetTarget オートメーションの値です。 どちらの場合も、オートメーション曲線は連続しています。

linearRampToValueAtTime(value, endTime)

前にスケジュールされているパラメータ値から指定された値まで、直線的に連続して値を変化させる事をスケジュールします。

時間範囲 \(T_0 \leq t < T_1\) ( ここで \(T_0\) は前のイベントの時刻、\(T_1\) はこのメソッドで指定された endTime です ) の間の値は次のように計算されます :

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

ここで \(V_0\) は時刻 \(T_0\) での値、\(V_1\) はこのメソッドで指定された value パラメータです。

もしこの LinearRampToValue イベント以降にイベントがない場合、\(t \geq T_1\) に対して \(v(t) = V_1\) となります。

もしこのイベントにより前にイベントが存在しない場合、直線変化は setValueAtTime(value, currentTime) が呼び出されたかのように動作します。 ここで value は属性の現在の値で currentTime は linearRampToValueAtTime() が呼び出されたときのコンテキストの currentTime です。

もし、前のイベントが SetTarget イベントの場合、\(T_0\) と \(V_0\) は SetTarget オートメーションの現在の時刻と値から選択されます。 つまり SetTarget イベントがまだ開始されていない場合、\(T_0\) はイベントの開始時刻であり、\(V_0\) は SetTarget イベントの開始直前の値です。 この場合、LinearRampToValue イベントは実質的に SetTarget イベントを置き換えます。 SetTarget イベントが既に開始されている場合、\(T_0\) は現在のコンテキストの時刻であり、\(V_0\) は時刻 \(T_0\) での現在の SetTarget オートメーションの値です。 どちらの場合も、オートメーションの曲線は連続しています。

setTargetAtTime(target, startTime, timeConstant)

指定の時刻から、指定の時定数によって指数的に目標の値に漸近を開始します。 様々な使い方がありますが、これは ADSR エンベロープの "ディケイ" および "リリース" を実装する際に役立ちます。 値は指定の時刻に即、目標値になるのではなく徐々に目標値に向かって変化する事に注意してください。

時間範囲 \(T_0 \leq t\) について、ここで \(T_0\) は startTime パラメータの時刻として :

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

ここで \(V_0\) は \(T_0\) ( startTime パラメータ ) での初期値 ( [[current value]] 属性の値 )、\(V_1\) は target パラメータ、そして \(\tau\) は timeConstant パラメータです。

LinearRampToValue または ExponentialRampToValue イベントがこのイベントの後に続く場合、その動作はそれぞれ linearRampToValueAtTime() または exponentialRampToValueAtTime() で説明しています。 他のすべてのイベントの場合は、SetTarget イベントは次のイベントの時点で終了します。

AudioParam.setTargetAtTime() メソッドの引数 パラメータ 型 Null可 省略可 説明 target float ✘ ✘ パラメータが指定の時刻から変化を 開始 する際の目標値です。 startTime double ✘ ✘ AudioContext の currentTime 属性と同じ時間軸で指数的漸近を開始する時刻です。 もし start が負の値または有限数でない場合は RangeError 例外を発生します ( MUST )。 もし、startTime が currentTime よりも小さい場合、currentTime の値にクランプされます。 timeConstant float ✘ ✘ 目標値に漸近する一次フィルタ ( 指数 ) の時定数です。 この値が大きいと変化はゆっくりになります。 値は負の値ではならず ( MUST )、そうでない場合 RangeError 例外を発生します ( MUST )。 もし timeConstant がゼロの場合、出力値は直ちに最終値にジャンプします。 より正確には、timeConstant は、ステップ入力応答 ( 0 から 1 への遷移 ) が与えられた場合、一次線形連続時間不変システムが値 \(1 - 1/e\) ( 約 63.2% ) に達する時間です。

setValueAtTime(value, startTime)

指定の時刻になるとパラメータ値を変更するようにスケジュールします。

もしこの SetValue イベントの後にもうイベントがない場合、\(t \geq T_0\) に対して \(v(t) = V\)、ここで \(T_0\) は startTime パラメータ 、そして \(V\) は value パラメータの値です。 別の言い方をすれば、値は定数のまま保持されます。

もしこの SetValue イベントの次のイベント ( 時刻は \(T_1\) ) が LinearRampToValue または ExponentialRampToValue でない場合、\(T_0 \leq t < T_1\) は :

$$
    v(t) = V
$$

別の言い方をすれば、値に "ステップ" を作ってこの期間、定数のまま保持されます。

この SetValue イベントに続く次のイベントが LinearRampToValue 型または ExponentialRampToValue 型の場合、linearRampToValueAtTime() または exponentialRampToValueAtTime() をそれぞれ参照してください。

setValueCurveAtTime(values, startTime, duration)

指定の時刻と期間に対して、任意の値の配列を設定します。 値の個数は必要とされる期間に合うようにスケーリングされます。

\(T_0\) を startTime 、\(T_D\) を duration 、\(V\) を values 配列、\(N\) を values 配列の長さとすると、期間 \(T_0 \le t < T_0 + T_D\) の間、次のようになります :

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

そして \(v(t)\) は \(V[k]\) と \(V[k+1]\) の間で直線補間されます。

曲線の期間が終了した後、(\(t \ge T_0 + T_D\)) に対して値は ( もしあれば ) 別のオートメーションイベントまで、最後の曲線の値を保持します。

時刻 \(T_0 + T_D\)、値 \(V[N-1]\) として暗黙的な setValueAtTime() の呼び出しが行われ、以後のオートメーションは setValueCurveAtTime() イベントの終わりから開始するようになります。

AudioParam には、単純パラメータ と 複合パラメータ という 2 つの異なる種類があります。 単純パラメータ ( デフォルト ) は、AudioNode の最終的なオーディオ出力を計算するために単独で使用されます。 複合パラメータ は、他の AudioParam と一緒に合わせて計算された値が、AudioNode の出力を計算するための入力となる AudioParam です。

computedValue はオーディオ DSP を制御する最終的な値であり、オーディオレンダリングスレッドによって、それぞれのレンダリング量子の時刻に計算します。

computedValue の 公称範囲 は、このパラメータが実質的に持つことができる最小値と最大値です。 単純パラメータ の場合、computedValue はこのパラメータの 単純な公称範囲 内にクランプされます。 複合パラメータ では、複合される別の AudioParam の値と合わせて計算された後、最終的な値が 公称範囲 にクランプされます。

オートメーションメソッドを使用する場合にも、クランプは依然として適用されます。 ただし、オートメーション自体はクランプが全くないかのように実行され、オートメーションの値が出力に適用される際にのみ、上記のクランプが実行されます。

例えば、ノード \(N\) が \([0, 1]\) の公称範囲を有する AudioParam \(p\) を持っているとき、次のオートメーションのシーケンスは

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

曲線の最初の勾配は 4 であり、最大値 1 に達すると出力は一定に保たれます。 最後に、時刻 2 の近くで、曲線の傾きは -4 になります。 これを図示したのが下のグラフで、破線はクリッピングされない場合に何が起こったかを示し、実線は公称範囲へのクリッピングによる audioparam の実際の予想される動作を示しています。

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

このインタフェースは、AudioBufferSourceNode 、ConstantSourceNode 、および OscillatorNode などのソースノードの共通の機能を表します。

( start() を呼び出すことによって ) ソースが開始されるより前は、ソースノードは無音 ( 0 ) を出力しなければなりません ( MUST )。 ( stop() を呼び出すことによって ) ソースが停止した後、ソースは無音 ( 0 ) を出力しなければなりません ( MUST )。

AudioScheduledSourceNode は直接インスタンス化することはできませんが、代わりにソースノードの具体的なインタフェースに拡張されています。

AudioScheduledSourceNode は関連付けられている BaseAudioContext の currentTime が AudioScheduledSourceNode が開始するように設定されている時間以上で、停止するように設定されている時間未満の場合に、再生中 になります。

AudioScheduledSourceNode は作成時から内部にブーリアンスロット [[source started]] を持っており、最初は false に設定されています。

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

onended, EventHandler 型

AudioScheduledSourceNode 型のノードにディスパッチされる ended イベントの イベントハンドラ を設定するために使用される属性です。 ソースノードが再生を停止した時 (具体的にはノードによって決定されます)、Event インタフェースを使用するイベントがイベントハンドラにディスパッチされます。

すべての AudioScheduledSourceNode は stop() によって設定された停止時間に達すると ended イベントが発行されます。 AudioBufferSourceNode の場合は、再生が duration の時間に達したか、buffer 全体を再生し終わった場合にも、イベントが送出されます。

start(when)

指定した時刻に音を再生するようにスケジュールします。

stop(when)

正確な時刻に音の再生を停止するようにスケジュールします。 もし stop がすでに呼び出された後に再度呼び出された場合は、最後の呼び出しだけが適用されます。 後続のコールの前にバッファがすでに停止していない限り、前回の呼び出しで設定された停止時刻は適用されません。 バッファがすでに停止している場合は、さらに stop を呼び出しても効果はありません。 スケジュールされた開始時刻よりも前に停止時刻に達すると、音は再生されません。

このインタフェースはリアルタイムの周波数および時間領域の分析を可能にするノードを表します。 オーディオストリームは加工されずに入力から出力に渡されます。

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

AnalyserNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

fftSize, , unsigned long 型

周波数領域の分析に使用する FFT のサイズ ( サンプルフレーム数 ) です。 これは 32 から 32768 までの 2 の累乗でなくてはならず ( MUST )、そうでなければ、IndexSizeError 例外を発生します ( MUST )。 デフォルトの値は 2048 です。 大きな FFT サイズは計算量が増加する事に注意してください。

fftSize が異なる値に変更されると、( getByteFrequencyData() および getFloatFrequencyData() の ) 周波数データの平滑化に関連するすべての状態がリセットされます。 つまり、時間の経過による平滑化 に使用される 前のブロック のデータ、\(\hat{X}_{-1}[k]\) が、すべての \(k\) に対して 0 に設定されます。

fftSize を増加させた時、現在の時間領域のデータ はそれまでと異なり、より過去のサンプルフレームを含んで伸長する必要があることに注意してください。 これは実質的に AnalyserNode は最後の 32768 のサンプルフレームを常に保持しなければならない ( MUST ) ことを意味し、現在の時間領域のデータ は、常に最新の fftSize の大きさのサンプルフレームとなります。

frequencyBinCount, unsigned long 型, readonly

FFT サイズの半分の値です。

maxDecibels, double 型

maxDecibels は FFT 解析データを unsigned byte 値へ変換するスケーリングの際の最大パワー値です。 デフォルトの値は -30 です。 もしこの属性の値が minDecibels より小さいか同じ値に設定された場合 IndexSizeError 例外を発生します ( MUST )。

minDecibels, double 型

minDecibels は FFT 解析データを unsigned byte 値へ変換するスケーリングの際の最少パワー値です。 デフォルトの値は -100 です。 もしこの属性の値が maxDecibels よりも大きいか同じに設定された場合 IndexSizeError 例外を発生します ( MUST )。

smoothingTimeConstant, double 型

0 -> 1 の範囲の値で、0 ならば最後の解析フレームに対して時間平均が取られない事を表します。 デフォルトの値は 0.8 です。 もしこの属性の値が 0 より小さいか 1 より大きい値が設定された場合 IndexSizeError 例外を発生します ( MUST )。

getByteFrequencyData(array)

現在の周波数データ を array に 書き込み ます。 array の バイト長 が frequencyBinCount より短い場合、余った要素は捨てられます。 array の バイト長 が frequencyBinCount より大きい場合、超過分の要素は無視されます。 周波数データの計算には、最新の fftSize のフレームが使用されます。

getByteFrequencyData() または getFloatFrequencyData() への別の呼び出しが前の呼び出しと同じ レンダリング量子 内で発生した場合、現在の周波数データ は同じデータで更新されません。 代わりに、以前に計算されたデータが返されます。

符号なしバイト配列に格納される値は次のように計算されます。 FFT 窓関数と時間的スムージング で説明されているように \(Y[k]\) を 現在の周波数データ とします。 次に、バイト値 \(b[k]\) は

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

ここで \(\mbox{dB}_{min}\) は minDecibels 、そして \(\mbox{dB}_{max}\) は maxDecibels です。 もし \(b[k]\) が 0 から 255 の範囲外である場合は \(b[k]\) はその範囲に収まるようにクリップされます。

getByteTimeDomainData(array)

現在の時間領域データ ( 波形データ ) を array に 書き込み ます。 array の バイト長 が fftSize より短い場合、余った要素は捨てられます。 array の バイト長 が fftSize より大きい場合、超過分の要素は無視されます。 バイトデータの計算には、最新の fftSize のフレームが使用されます。

符号なしバイト配列に書き込まれる値は次のように計算されます。 \(x[k]\) を時間領域データとします。 バイト値 \(b[k]\) は、

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

もし \(b[k]\) が 0 から 255 の範囲外の場合、\(b[k]\) は範囲内にクリップされます。

getFloatFrequencyData(array)

現在の周波数データ を array に 書き込み ます。 array の要素数が frequencyBinCount より少ない場合、余った要素は捨てられます。 array の要素数が frequencyBinCount より多い場合、超過分の要素は無視されます。 周波数データの計算には最新の fftSize のフレームが使用されます。

以前の呼び出しと同じ レンダリング量子 内で getFloatFrequencyData() または getByteFrequencyData() が再度呼び出された場合、現在の周波数データ は同じデータで更新されず、代わりに以前に計算されたデータが返されます。

周波数データの単位は dB です。

getFloatTimeDomainData(array)

現在の時間領域データ (波形データ) を array に 書き込み ます。 array の要素数が fftSize の値より少ない場合、余った要素は捨てられます。 array の要素数が fftSize の値より多い場合、超過分の要素は無視されます。 最新の fftSize フレームが書き込まれます (ダウンミックス後)。

これは AnalyserNode を生成する際に使用するオプションを指定します。 すべてのメンバーは省略可能で、もし指定されない場合は通常のデフォルト値がノードの生成に使用されます。

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

fftSize, unsigned long 型, デフォルト値は 2048

周波数領域解析のための FFT サイズとして要求する初期値です。

maxDecibels, double 型, デフォルト値は -30

FFT 解析の最大パワー (dB) として要求する初期値です。

minDecibels, double 型, デフォルト値は -100

FFT 解析の最小パワー (dB) として要求する初期値です。

smoothingTimeConstant, double 型, デフォルト値は 0.8

FFT 解析のスムーズ化定数として要求する初期値です。

現在の時間領域データ が計算されるとき、入力信号は channelCount が 1、channelCountMode が "max" であり、channelInterpretation が "speakers" であるかのように、モノラルに ダウンミックス されなければなりません。 これは、AnalyserNode 自体の設定とは無関係です。 最新の fftSize フレームがこのダウンミックス処理に使用されます。

現在の周波数データ が計算されるとき、次の処理が行われます :

次の式では \(N\) をこの AnalyserNode の fftSize 属性の値とします。

は時間領域の入力に対して次の処理を行います。 \(n = 0, \ldots, N - 1\) に対する \(x[n]\) は時間領域のデータです。 ブラックマン窓は次のように定義されます。

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

窓関数を通した信号 \(\hat{x}[n]\) は

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

は次のようなフーリエ変換の計算から成ります。 \(X[k]\) は複素周波数領域のデータで \(\hat{x}[n]\) は上で計算された窓関数を通した時間領域のデータです。 そして、

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

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

周波数データの

は次のように処理されます :

• \(\hat{X}_{-1}[k]\) を 前回のブロック に対するこの処理の結果とします。 前回のブロック は前回の 時間的スムージング 処理で計算されたバッファとして定義され、もし 時間的スムージング 処理が最初の 1 回目の場合は \(N\) 個の 0 からなる配列になります。

• \(\tau\) を この AnalyserNode の smoothingTimeConstant 属性の値とします。

• \(X[k]\) を現在のブロックの フーリエ変換の適用 の結果とします。

そしてスムージングされた値 \(\hat{X}[k]\) は次の式で計算されます

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

• もし \(\hat{X}[k]\) が NaN、正の無限大または負の無限大 ならば \(\hat{X}[k]\) = 0 とします。

ただし \(k = 0, \ldots, N - 1\).

このインタフェースは AudioBuffer によってメモリー上に保持されているオーディオデータからのオーディオソースを表します。 これはオーディオデータの再生に高度なスケジューリングの柔軟性と精度が要求される場合に役立ちます。 もしネットワークからあるいはディスクからのデータをサンプル精度で再生する必要がある場合、再生機能の実装には AudioWorkletNode を使用しなくてはなりません。

start() メソッドはいつ再生されるかをスケジュールするために使用されます。 start() メソッドを複数回呼び出す事はできません。 再生は ( もし loop 属性が false の場合 ) バッファのオーディオデータがすべて再生されると、あるいは stop() メソッドが呼び出されて指定された時刻になると自動的に停止します。 より詳細には start() および stop() の説明を参照してください。

出力のチャンネル数は常に buffer 属性に指定された AudioBuffer のチャンネル数と同じになります。 もし buffer が null の場合、チャンネルは無音の 1 チャンネルとなります。

さらに、バッファに 1 つ以上のチャンネルがある場合 AudioBufferSourceNode の出力は、次のいずれかの条件が成立した後、レンダリング量子の開始時に 1 チャンネルの無音に変化しなくてはなりません :

• buffer の終わりに到達しました

• duration の終わりに到達しました

• stop の指定時刻に到達しました

AudioBufferSourceNode の 再生ヘッド位置 は、バッファ内の最初のサンプルフレームの時刻を基準にした秒単位の時間オフセットとして定義される値です。 その値はノードの playbackRate および detune パラメータとは独立したものとして想定されます。 一般に、再生ヘッド位置はサブサンプルの精度であり、正確なサンプルフレームの位置を参照するものではありません。 その値は 0 とバッファ全体の長さの間で有効な値を取ります。

playbackRate および detune 属性は、複合パラメータ を形成します。 それらは組み合わせて使用され、次のように computedPlaybackRate 値を決定します :

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

この 複合パラメータ の 公称範囲 は \((-\infty, \infty)\) です。

AudioBufferSourceNode は作成された時から ブーリアンの内部スロット [[buffer set]] を持っており、初期値は false に設定されています。

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

AudioBufferSourceNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される時、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

buffer, AudioBuffer 型, nullable

再生されるオーディオのリソースを表します。

detune, AudioParam 型, readonly

オーディオストリームをレンダリングする速度を変調する追加のパラメータで、単位はセントです。 このパラメータは、playbackRate と組み合わせて computedPlaybackRate を計算する 複合パラメータ です。

loop, boolean 型

オーディオデータの loopStart と loopEnd で指定された範囲を繰り返してループ再生するかどうかを指定します。 デフォルトは false です。

loopEnd, double 型

loop 属性が true の場合、ループの終了位置を示すオプションの 再生ヘッド位置 です。 その値そのものはループ範囲に含まれません。 そのデフォルトの value は 0 で、通常は 0 から バッファの長さの範囲の任意の値に設定できます。 loopEnd が 0 より小さいまたは 0 である、または loopEnd がバッファの長さよりも長い場合、ループはバッファの最後が終了位置になります。

loopStart, double 型

loop 属性が true の場合にループを開始するオプションの 再生ヘッド位置 です。 そのデフォルトの value は 0 で、0 からバッファの長さの範囲の任意の値に設定できます。 もし loopStart が 0 より小さい場合、ループは 0 から開始します。 もし loopStart がバッファの長さより大きい場合、ループはバッファの最後から開始します。

playbackRate, AudioParam 型, readonly

オーディオストリームをレンダリングする速度です。 これは、detune と組み合わせて computedPlaybackRate が計算される 複合パラメータ です。

start(when, offset, duration)

指定の時刻に音の再生開始をスケジュールします。

AudioBufferSourceNode を生成する際のオプションを指定します。 すべてのメンバーは省略可能です。 指定されていない場合、通常のデフォルト値がノードの生成に使用されます。

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

buffer, AudioBuffer 型, nullable

再生するオーディオのデータを指定します。 これは buffer を AudioBufferSourceNode の buffer 属性に割り当てるのと等価です。

detune, float 型, デフォルト値は 0

detune AudioParam の初期値です。

loop, boolean 型, デフォルト値は false

loop 属性の初期値です。

loopEnd, double 型, デフォルト値は 0

loopEnd 属性の初期値です。

loopStart, double 型, デフォルト値は 0

loopStart 属性の初期値です。

playbackRate, float 型, デフォルト値は 1

playbackRate AudioParam の初期値です。

このセクションは非基準情報です。 基準としての要件については 再生アルゴリズム を参照してください。

loop 属性を true に設定すると、端点 loopStart および loopEnd によって定義される範囲が、一度その範囲内のどこかが再生されると、その後範囲の再生を繰り返します。 loop が true である間、ループ再生は次のいずれかが発生するまで続きます :

• stop() が呼び出される。

• スケジュールされた停止時刻に到達する。

• start() が duration を指定して呼ばれている場合、その duration の値を超える。

ループの範囲は loopStart から 自身を含まない loopEnd までの領域を占めているとみなされます。 ループ範囲の再生方向は、ノードの再生速度の符号を考慮します。 再生速度が正の場合、ループは loopStart から loopEnd まで; 再生速度が負の場合は loopEnd から loopStart までのループが発生します。

ループは start() の offset 引数の解釈には影響しません。 再生は常に指定されたオフセットから開始され、再生中にループ範囲に差し掛かった場合にのみループが開始されます。

有効なループ開始点と終了点は、後述のアルゴリズムで定義されているように、0 から バッファの長さの間にある必要があります。 loopEnd は loopStart と同じかより後ろになるようにさらに制約されます。 これらの制約のいずれかに沿わない場合は、ループ範囲はバッファ全体を指すとみなされます。

ループの端点はサブサンプルの精度で扱われます。 端点が正確なサンプルフレームのオフセットにならない場合、または再生レートが 1 に等しくない場合、ループの再生は、ループの終了点と開始点が一致するように繋ぎ合わされ、それがバッファの連続した領域のオーディオであるように補間されます。

ループ関連のプロパティは、バッファの再生中に変化させても良く、一般に次のレンダリング量子から有効となります。 正確な内容については、後述の基準としての再生アルゴリズムによって定義されます。

loopStart と loopEnd 属性のデフォルト値はどちらも 0 です。 loopEnd の値が 0 である事はバッファ全体の長さと等価であるため、デフォルトのループ範囲はバッファ全体になります。

ループの端点の値は、バッファのサンプルレートを前提とした時間のオフセットとして表されています。 これらの値は再生中に動的に変化可能なノードの playbackRate パラメータとは無関係であることに注意してください。

この基準情報のセクションでは、再生中に動的に変化する可能性がある次の要素の組み合わせの影響を考慮しつつ、バッファ内容の再生について定義します :

• サブサンプル精度で表現される開始オフセット。

• サブサンプル精度で表現され、再生中に動的に変化可能なループポイント。

• 再生速度とデチューンパラメータ。 これらは組み合わされて、単一の computedPlaybackRate となり、その値は有限の正または負の値となります。

AudioBufferSourceNode の出力を生成するための内部のアルゴリズムは、以下の原則に従います :

• 出力の効率または品質を向上させるため、バッファのリサンプリングが必要になったとき、任意に UA によって実行されます

• サブサンプル単位の開始オフセットまたはループポイントは、サンプルフレーム間に補間を必要とすることがあります。

• ループバッファの再生は、補間による影響を除いて、ループ部のオーディオ内容が連続して繰り返される非ループのバッファと同じように振舞わなくてはなりません。

アルゴリズムの説明は次のとおりです :

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

次の非基準の図は、様々な主要シナリオでのアルゴリズムの動作を示しています。 バッファの動的なリサンプリングは考慮されませんが、ループ位置の時間が変更されない限り、結果の再生には重大な影響はありません。 すべての図において、次の規則が適用されます :

• コンテキストのサンプルレートは 1000 Hz とします。

• AudioBuffer の内容の最初のサンプルを x の原点とします。

• x 原点を start の時刻として出力信号をサンプルフレームとともに示します。

• UA は他の補間技術を使う事もできますが、直線補間として図示しています。

• 図に示されている duration の値は、start() の引数ではなく buffer を参照します。

この図は、バッファ内の最後のサンプルフレームの後にエンドポイントがある単純なループがあるバッファの基本的な再生を示しています :

この図は、playbackRate の補間を示し、1 つおきに出力サンプルフレームが補間される、バッファコンテンツの半分の速度での再生を示しています。 特に注目すべき点は、ループされた出力の最後のサンプルフレームで、ループの開始点を使用して補間されます。

この図はサンプルレートの補間を示し、サンプルレートがコンテキストのサンプルレートの 50% であるバッファの再生を示しています。 バッファとコンテキストとの間のサンプルレートの差を補正するために、計算された再生レートは 0.5 となります。 結果の出力は前の例と同じですが、理由は異なります。

この図は、バッファ内のオフセットがサンプルフレームのちょうど半分で始まるサブサンプルオフセットの再生を示しています。そのため、すべての出力フレームが補間されます :

この図は、ループの端点の小数点以下を持つフレームオフセットが、正確なサンプルフレームを参照している場合と同じように、オフセットに従ってバッファ内の補間データポイントにどのようにマップするかを示すサブサンプルループ再生を示しています :

これはユーザーが聴く事になる最終的な音の出力地点を表す AudioNode です。 それは多くの場合、スピーカーが接続されているオーディオ出力デバイスと考えられます。 聴こえるべきすべてのレンダリングされた音は AudioContext のルーティンググラフの "終端点" であるこのノードに導かれます。 AudioDestinationNode は 1 つの AudioContext に付き、AudioContext の destination 属性を介して 1 つだけ存在します。

AudioDestinationNode の出力はその 入力を足し合わせる ことによって生成され、AudioContext の出力を例えば MediaStreamAudioDestinationNode または MediaRecorder ( [mediastream-recording] で説明されています ) で取り込むこともできます。

AudioDestinationNode は、AudioContext または OfflineAudioContext のいずれかの出力先であり、チャンネルのプロパティはコンテキストが何であるかによって異なります。

AudioContext の場合のデフォルトは

channelCount は maxChannelCount と同じか小さい任意の値に設定できます。 この値が有効な範囲内にない場合は、IndexSizeError 例外を発生します ( MUST )。 具体的な例を挙げると、オーディオハードウェアが 8 チャンネル出力をサポートする場合、channelCount を 8 に設定する事で 8 チャンネルの出力をレンダリングすることができます。

OfflineAudioContext の場合のデフォルトは

ここで numberOfChannels は OfflineAudioContext を生成するときに指定されたチャンネルの数です。 この値は変更できません。 channelCount が別の値に変更された場合、NotSupportedError 例外を発生します ( MUST )。

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

maxChannelCount, unsigned long 型, readonly

channelCount 属性に設定できるチャンネルの最大数です。 ( 通常の場合 ) 終点としてオーディオハードウェアを表す AudioDestinationNode は、オーディオハードウェアがマルチチャンネル対応である場合、2 よりも大きなオーディオチャンネルを出力する可能性があります。 maxChannelCount は、このハードウェアがサポートできるチャンネルの最大数です。

このインタフェースは人がオーディオシーンを聴く位置と方向を表します。 すべての PannerNode オブジェクトは BaseAudioContext の listener との関係で空間音響処理を行います。 空間音響についての詳細は § 6 空間音響 / パンニング を参照してください。

positionX 、positionY 、positionZ パラメータは、3D デカルト座標空間におけるリスナーの位置を表します。 PannerNode オブジェクトは、これと個々の音源との相対位置を空間音響に使用します。

forwardX 、forwardY 、forwardZ パラメータは、3D 空間内の方向ベクトルを表します。 forward ベクトルと up ベクトルの両方が、リスナーの向きを決定するために使用されます。 わかりやすく人間で言えば、forward ベクトルは、人の鼻がどの方向を指しているかを表します。 up のベクトルは、人の頭の上を指している方向を表します。 これらの 2 つのベクトルは線形独立であると考えられます。 これらの値がどのように解釈されるかの基準としての要件については、§ 6 空間音響 / パンニング のセクションを参照してください。

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

forwardX, AudioParam 型, readonly

3D デカルト座標空間内で、リスナーが向いている forward 方向の x 座標成分です。

forwardY, AudioParam 型, readonly

3D デカルト座標空間内で、リスナーが向いている forward 方向の y 座標成分です。

forwardZ, AudioParam 型, readonly

3D デカルト座標空間内で、リスナーが向いている forward 方向の z 座標成分です。

positionX, AudioParam 型, readonly

3D デカルト座標空間内での、オーディオリスナーの位置の x 座標です。

positionY, AudioParam 型, readonly

3D デカルト座標空間内での、オーディオリスナーの位置の y 座標です。

positionZ, AudioParam 型, readonly

3D デカルト座標空間内での、オーディオリスナーの位置の z 座標です。

upX, AudioParam 型, readonly

3D デカルト座標空間内で、リスナーの頭上の up 方向の x 座標成分です。

upY, AudioParam 型, readonly

3D デカルト座標空間内で、リスナーの頭上の up 方向の y 座標成分です。

upZ, AudioParam 型, readonly

3D デカルト座標空間内で、リスナーの頭上の up 方向の z 座標成分です。

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

このメソッドは非推奨 (DEPRECATED) です。 これは forwardX.value 、forwardY.value 、forwardZ.value 、upX.value 、upY.value 、upZ.value に、与えられた x 、y 、z 、xUp 、yUp 、zUp の値をそれぞれ直接設定するのと等価です。

そのため、forwardX 、forwardY 、forwardZ 、upX 、upY 、upZ の AudioParam のいずれかに、setValueCurveAtTime() を使用したオートメーションカーブがあるときに、このメソッドを呼び出すと NotSupportedError を発生します ( MUST )。

setOrientation() はリスナーが 3D デカルト座標空間でどの方向を指しているかを示します。 forward ベクトルと up ベクトルの両方が与えられます。 わかりやすく人間で言えば、forward ベクトルは、人の鼻がどの方向を向いているかを表します。 up ベクトルは、人の頭の上を指している方向を表します。 これらの2つのベクトルは線形独立であると考えられます。 これらの値がどのように解釈されるかの基準としての要件については、§ 6 空間音響 / パンニング のセクションを参照してください。

x 、y 、z パラメータは、3D 空間における forward 方向ベクトルを表し、デフォルト値は ( 0, 0, -1 ) になります。

xUp 、yUp 、zUp パラメータは、3D 空間内の up 方向ベクトルを表し、デフォルト値は ( 0, 1, 0 ) になります。

setPosition(x, y, z)

このメソッドは非推奨 (DEPRECATED) です。 これは、positionX.value 、positionY.value 、positionZ.value にそれぞれ与えられた x 、y 、z の値を直接設定することと等価です。

そのため、AudioListener の positionX 、positionY 、positionZ の AudioParam のいずれかに、setValueCurveAtTime() を使用したオートメーションカーブがあるときに、このメソッドを呼び出すと NotSupportedError を発生します ( MUST )。

setPosition() はリスナーの位置を 3D デカルト座標空間に設定します。 PannerNode オブジェクトは、この位置と個々の音源の相対位置を空間音響に使用します。

x 、y 、z パラメータは 3D 空間内の座標を表しています。

デフォルトの値は (0, 0, 0) です。

AudioListener のパラメータには AudioNode を接続する事ができ、それが同じグラフ内の PannerNode の出力にも影響を与えるため、ノードの順序付けアルゴリズムで処理の順序を計算する際には AudioListener を考慮する必要があります。 このためグラフ内のすべての PannerNode は入力として AudioListener を持っています。

これは ScriptProcessorNode ノードにディスパッチされる Event オブジェクトです。 置き換えとなる AudioWorkletNode は異なるアプローチを使用するため、ScriptProcessorNode が削除される際には削除されます。

このイベントのハンドラは inputBuffer 属性を経由してオーディオデータにアクセスすることによって、( もしあれば ) 入力からのオーディオを処理します。 処理の結果 ( または入力がない場合は合成したデータ ) であるオーディオデータは、outputBuffer に格納されます。

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

inputBuffer, AudioBuffer 型, readonly

入力となるオーディオデータを含む AudioBuffer です。 これは createScriptProcessor() メソッドの numberOfInputChannels パラメータと等しい数のチャンネルを持っています。 この AudioBuffer は、audioprocess 関数の範囲内でのみ有効です。 このスコープの外では値は意味を持ちません。

outputBuffer, AudioBuffer 型, readonly

出力のオーディオデータを書き込まなくてはならない AudioBuffer です ( MUST )。 この AudioBuffer は createScriptProcessor() メソッドの numberOfOutputChannels パラメータと等しい数のチャンネルを持っています。 audioprocess イベントハンドラ関数のスコープ内のスクリプトコードは、この AudioBuffer のチャンネルデータを表す Float32Array 配列を変更することを期待されています。 このスコープの外でのスクリプトによる AudioBuffer の変更では、オーディオに対する効果は発生しません。

playbackTime, double 型, readonly

AudioContext の currentTime と同じ時間軸で表される、このオーディオが再生される時刻です。

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

inputBuffer, AudioBuffer 型

イベントの inputBuffer 属性に割り当てられる値です。

outputBuffer, AudioBuffer 型

イベントの outputBuffer 属性に割り当てられる値です。

playbackTime, double 型

イベントの playbackTime 属性に割り当てられる値です。

BiquadFilterNode は、よくある低次フィルタを実装した AudioNode です。

低次フィルタは基本的なトーンコントロール (バス、ミドル、トレブル) やグラフィックイコライザーやより高度なフィルタを構成するブロックです。 複数の BiquadFilterNode フィルタを組み合わせてより複雑なフィルタを作る事もできます。 フィルタのパラメータの frequency などを時間と共に変化させてフィルタスイープやその他の効果を得る事もできます。 それぞれの BiquadFilterNode は下の IDL で紹介する様々な一般的なフィルタの型のうちの 1 つに設定する事ができます。 デフォルトのフィルタの型は "lowpass" です。

frequency と detune は 複合パラメータ で、どちらも a-rate パラメータです。 これらは computedFrequency の値を決定するために一緒に使用されます:

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

この 複合パラメータ の 公称範囲 は [0, Nyquist frequency] です。

出力のチャンネル数は常に入力のチャンネル数と同じになります。

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

frequency

カットオフ周波数です。

Q

カットオフ周波数にどれだけピークを付けて共振させるかを制御します。 大きな値はより強く共振させます。

gain

このフィルタのタイプでは使用しません。

frequency

これより低い周波数を減衰させるカットオフ周波数です。

Q

カットオフ周波数にどれだけピークを付けて共振させるかを制御します。 大きな値はより強く共振させます。

gain

このフィルタのタイプでは使用しません。

frequency

周波数範囲の中心周波数です。

Q

周波数範囲の幅を制御します。 この幅は Q の値が増加すると狭くなります。

gain

このフィルタのタイプでは使用しません。

frequency

増幅 ( または減衰 ) させる上限の周波数です。

Q

このフィルタのタイプでは使用しません。

gain

dB で表した増幅率です。 もしこの値が負ならばその周波数は減衰されます。

frequency

増幅 ( または減衰 ) させる下限の周波数です。

Q

このフィルタのタイプでは使用しません。

gain

dB で表した増幅率です。 もしこの値が負ならばその周波数は減衰されます。

frequency

増幅される中心の周波数です。

Q

増幅される周波数の幅を制御します。 値が大きいと幅は狭くなります。

gain

dB で表した増幅率です。 もしこの値が負ならばその周波数は減衰されます。

frequency

ノッチを適用する中心の周波数です。

Q

減衰させる周波数帯の幅を制御します。 大きな値は幅が狭い事を意味します。

gain

このフィルタのタイプでは使用しません。

frequency

位相変化が発生する中心の周波数です。 別の見方では 群遅延 が最大になる周波数です。

Q

中心周波数での位相変化がどれくらい急峻であるかを制御します。 値が大きいと、より急峻な位相変化で大きな群遅延である事を意味します。

gain

このフィルタのタイプでは使用しません。

BiquadFilterNode の属性はすべて a-rate の AudioParam です。

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

BiquadFilterNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

Q, AudioParam 型, readonly

フィルタの Q ファクターです。

lowpass および highpass フィルタの場合、Q 値は dB 単位であると解釈されます。 これらのフィルタの公称範囲は \([-Q_{lim}, Q_{lim}]\) となり、ここで \(Q_{lim}\) は \(10^{Q/20}\) がオーバーフローしない最大の値です。 これは 約 \(770.63678\) となります。

bandpass 、notch 、allpass 、peaking フィルタの場合、この値はリニア値です。 この値はフィルタの帯域幅に関連しているため、正の値でなければなりません。 公称範囲は \([0, 3.4028235e38]\) で、上限は 最も正の単精度浮動小数点値 です。

これは lowshelf 、highshelf フィルタでは使用されません。

detune, AudioParam 型, readonly

周波数のデチューン値で単位はセントです。 これは frequency と組み合わされて 複合パラメータ となり、computedFrequency を決定します。

frequency, AudioParam 型, readonly

Hz であらわした BiquadFilterNode が働く周波数です。 これは detune と組み合わされて 複合パラメータ となり computedFrequency を決定します。

gain, AudioParam 型, readonly

フィルタのゲインで、単位は dB です。 ゲインは lowshelf 、highshelf 、peaking 型のフィルタでのみ使用されます。

type, BiquadFilterType 型

この BiquadFilterNode のタイプです。 デフォルトの値は "lowpass" です。 type 属性の値によって他のパラメータの正確な意味が変わってきます。

getFrequencyResponse(frequencyHz, magResponse, phaseResponse)

フィルタの各パラメータの現在の値 [[current value]] に基づいて、指定の周波数に対する周波数応答を同期的に計算します。 3つの引数は、同じ長さの Float32Array である必要があります。 そうでない場合、InvalidAccessError を発生します ( MUST )。

返される周波数応答は、現在の処理ブロックに対してサンプリングされた AudioParam を使用して計算されなくてはなりません ( MUST )。

これは BiquadFilterNode を作成する際に使用されるオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合は、通常のデフォルト値を使用してノードが作成されます。

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

Q, float 型, デフォルト値は 1

Q の初期値として要求する値です。

detune, float 型, デフォルト値は 0

detune の初期値として要求する値です。

frequency, float 型, デフォルト値は 350

frequency の初期値として要求する値です。

gain, float 型, デフォルト値は 0

gain の初期値として要求する値です。

type, BiquadFilterType 型, デフォルト値は "lowpass"

フィルタの type の初期値として要求する値です。

BiquadFilterNode であるタイプのフィルタを実装する方法は複数あり、それぞれが非常に様々な特性を持っています。 このセクションの式はフィルタのタイプごとの特性を決定するもので、仕様に準拠する実装 として実装しなければならないフィルタについて記述しています ( MUST )。 これらの式は Audio EQ Cookbook で見られる式を基にしています。

BiquadFilterNode のオーディオ処理の伝達関数は

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

これは時間領域での次の式と等価です :

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

フィルタの初期状態は 0 です。

注 : 固定状態のフィルタは安定していますが、AudioParam のオートメーションを使って不安定なバイクワッドフィルタを作る事も可能です。 これを管理するのは開発者の責任になります。

注 : UAは、フィルタ状態に NaN 値が発生したことをユーザーに通知する警告を生成する場合があります。 これは通常、フィルタが不安定である事を示しています。

上記の伝達関数内の係数はそれぞれのノードのタイプによって異なります。 BiquadFilterNode の AudioParam の computedValue を基として次の中間変数が計算のために必要になります。

• \(F_s\) をこの AudioContext の sampleRate 属性の値とします。

• \(f_0\) を computedFrequency の値とします。

• \(G\) を gain AudioParam の値とします。

• \(Q\) を Q AudioParam の値とします。

• これらより

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

各フィルタタイプに対応する 6 つの係数 (\(b_0, b_1, b_2, a_0, a_1, a_2\)) は :

"lowpass"

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

"highpass"

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

"bandpass"

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

"notch"

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

"allpass"

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

"peaking"

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

"lowshelf"

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

"highshelf"

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

ChannelMergerNode は高度なアプリケーションで、ChannelSplitterNode と組み合わせてよく使われます。

このインタフェースは複数のオーディオストリームからチャンネルを結合して 1 つのオーディオストリームにする AudioNode を表します。 これは可変数の入力 (デフォルトは 6 ) の入力を持ちますが、すべての入力を接続する必要はありません。 いずれかの入力が アクティブに処理 されている場合、チャンネル数が入力の数に等しい 1 つの出力があります。 どの入力も アクティブに処理 されていない場合、出力は無音の 1 チャンネルになります。

複数の入力を 1 つの出力にまとめるとき、それぞれの入力は指定されたミキシングルールによって 1 チャンネル ( モノラル ) にダウンミックスされます。 接続されていない入力も 1 チャンネルの無音 としてカウントされて出力されます。 入力ストリームを変える事は出力のチャンネルの順序に 影響しません。

例えば、デフォルトの

に 2 つのステレオ入力が接続されている場合、1 番目の入力と 2 番目の入力は、マージされる前にそれぞれモノラルにダウンミックスされます。 出力は 6 チャンネルのストリームになり、最初の 2 つのチャンネルが最初の 2 つの (ダウンミックスされた) 入力で埋められ、残りのチャンネルは無音になります。

また、ChannelMergerNode を使用すると、5.1 サラウンドなどのマルチチャンネルスピーカー配列用に複数のオーディオ ストリームを特定の順序で配置できます。 マージャーではチャンネルを識別して (左、右などのように) 解釈するのではなく、単純に入力された順序でチャンネルが結合されるだけです。

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

ChannelMergerNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

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

numberOfInputs, unsigned long 型, デフォルト値は 6

ChannelMergerNode の入力の数です。 この値に対する制約については、createChannelMerger() を参照してください。

ChannelSplitterNode は高度なアプリケーションで、ChannelMergerNode と組み合わせてよく使われます。

このインタフェースはルーティンググラフ中のオーディオストリームの個別のチャンネルにアクセスする AudioNode を表しています。 これは 1 つの入力と入力のオーディオストリームのチャンネル数と同じ数の "アクティブ" な出力を持ちます。 例えば、ステレオの入力ストリームが ChannelSplitterNode に接続された場合、アクティブな出力は 2 ( 1 つは左チャンネルから、もう 1 つは右チャンネルから ) になります。 常に合計 N 個の出力 ( AudioContext の createChannelSplitter() の numberOfOutputs パラメータ で決まります ) があり、この値が渡されない場合のデフォルトの数は 6 になります。 "アクティブ" でないすべての出力は無音を出力し、通常はどこにも接続されません。

この例ではスプリッターはチャンネルの ( 例えば左チャンネル、右チャンネルなどの ) 識別はせず、単純に入力チャンネルの順序に従って出力チャンネルを分割する事に注意してください。

ChannelSplitterNode を使うアプリケーションの 1 つに、個別のチャンネルそれぞれのゲインの制御を必要とする "マトリックス・ミキシング" を行うものがあります。

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

ChannelSplitterNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

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

numberOfOutputs, unsigned long 型, デフォルト値は 6

ChannelSplitterNode の出力の数です。 この値の制約については、createChannelSplitter() を参照してください。

このインタフェースは、名目上一定の値を出力するオーディオソースを表します。 これは、一般的な定数ソースノードとして便利であり、また offset をオートメーションするか、別のノードを接続することで、生成可能な AudioParam であるかのように使用できます。

このノードの出力は 1 つだけで、1 チャンネル ( モノラル ) で構成されます。

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

ConstantSourceNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

offset, AudioParam 型, readonly

ソースとなる定数です。

ConstantSourceNode を生成するオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合、通常のデフォルトがノードの生成に使用されます。

dictionary ConstantSourceOptions {
    float offset = 1;
};

offset, float 型, デフォルト値は 1

このノードの offset AudioParam の初期値です。

このインタフェースはインパルスレスポンスに従って線形コンボリューションエフェクトを適用する処理ノードを表します。

このノードの入力はモノラル (1 チャンネル) またはステレオ (2 チャンネル) であり増やす事はできません。 より多いチャンネル数のノードからの接続は、適宜ダウンミックス されます。

このノードには、channelCount の制約 および channelCountMode の制約 があります。 これらの制約は、ノードへの入力がモノラルまたはステレオである事を確実にします。

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

ConvolverNode(context, options)

コンストラクタが BaseAudioContext context と オプションオブジェクト options と共に呼び出された場合、次の手順を実行します :

1. 属性 normalize を disableNormalization の値の逆に設定します。

2. buffer が 存在 する場合は、buffer 属性をその値に設定します。

   注 : これは、バッファが normalize 属性の値に従って正規化されることを意味します。

3. o を新しい AudioNodeOptions ディクショナリとします。

4. もし options に channelCount が 存在 している場合は o の channelCount を同じ値に設定します。

5. もし options に channelCountMode が 存在 している場合は o の channelCountMode を同じ値に設定します。

6. もし options に channelInterpretation が 存在 している場合は o の channelInterpretation を同じ値に設定します。

7. c 、o を引数として AudioNode this を 初期化 します。

buffer, AudioBuffer 型, nullable

この属性が設定された時点で、buffer と normalize 属性の状態を使って、このインパルス応答の指定の正規化がされた ConvolverNode が構成されます。 この属性の初期値は null です。

注 :buffer に新しいバッファを設定する際、オーディオにグリッジが発生します。 もしこれが望ましくない場合、置き換え用の新規の ConvolverNode を作成して両者の間でクロスフェードさせる事が推奨されます。

注 :ConvolverNode は、入力が 1 チャンネルで、かつ buffer が 1 チャンネルの場合にのみ、モノラル出力を生成します。 それ以外のすべてのケースで、出力はステレオになります。 特に buffer が 4 チャンネルであり、2 チャンネルの入力がある場合、ConvolverNode は "true" ステレオマトリックスの畳み込みを実行します。 基準となる情報については、チャンネル構成図 を参照してください。

normalize, boolean 型

buffer 属性がセットされたときに、バッファのインパルス応答を equal-power による正規化でスケーリングするかどうかを制御します。 様々なインパルス応答を読み込んだ場合に、Convolver が、より均一な出力レベルを出せるように、デフォルト値は true になっています。 もし normalize が false に設定されている場合、畳み込みはインパルス応答の前処理/スケーリングなしでレンダリングされます。 この値を変更した場合、もう一度 buffer 属性を設定するまで有効になりません。

buffer 属性が設定されたときに normalize 属性が false である場合、ConvolverNode は、buffer 内に保持されているインパルス応答そのままに、線形畳み込みを実行します。

そうでなく、もし、buffer 属性が設定されたときに normalize 属性が true である場合、ConvolverNode は、まず、buffer 内のオーディオデータのスケーリングされた RMS パワー解析を実行して、以下のアルゴリズムにより normalizationScale を計算します :

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

処理の際には、ConvolverNode はこの計算された normalizationScale の値を使い、入力と ( buffer で表される ) インパルス応答との線形畳み込みの結果に乗算して最終的な出力を得ます。 または、入力に対して事前に normalizationScale を乗算したり、インパルス応答に normalizationScale を事前に乗算したバージョンを作成しておくなど、数学的に同等の演算を使用してもかまいません。

ConvolverNode を作成する際のオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合、ノードは通常のデフォルトを使用して作成します。

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

buffer, AudioBuffer 型, nullable

ConvolverNode に要求するバッファ。 このバッファは、disableNormalization の 値に従って正規化されます。

disableNormalization, boolean 型, デフォルト値は false

ConvolverNode の normalize 属性として要求する初期値とは逆の値です。

実装は 1 または 2 チャンネルの入力に対する様々なリバーブエフェクトを実現するために次のような ConvolverNode のインパルスレスポンスのチャンネル構成をサポートしなくてはなりません ( MUST )。

下の図に示すように、単一チャンネルのコンポリューションはモノラルオーディオ入力に対してモノラルインパルスレスポンスを使用してモノラル出力を得ます。 残りの図は、入力チャンネル数が 1 または 2 のモノラルまたはステレオの再生で buffer のチャンネル数が 1、2、4 の場合を示しています。 開発者がより複雑な任意のマトリックスを必要とするなら ChannelSplitterNode と 複数の単一チャンネルの ConvolverNode および ChannelMergerNode を使用して構成する事もできます。

もしこのノードが アクティブに処理 をしていない場合は出力は 1 チャンネルの無音になります。

注 :下の図は アクティブに処理 をしている時を示しています。

ディレイ機能はオーディオアプリケーションの基本的な構成要素です。 このインタフェースは単一の入力と単一の出力を持つ AudioNode です。

出力のチャンネル数は、常に入力のチャンネル数と同じになります。

これは入力されるオーディオ信号を一定の量だけ遅延させます。 具体的には各時刻 t において、入力信号 input(t) に対して、遅延時間 delayTime(t)、出力信号 output(t) とすると 出力は output(t) = input(t - delayTime(t)) となります。 デフォルトの delayTime は 0 秒 (遅延なし)です。

DelayNode の入力のチャンネル数を変えたとき (つまり出力チャンネル数もまた変化します)、ノードからまだ出力されておらず内部状態にあるサンプルが残っているかも知れません。 すべての内部のディレイ機能のミキシングは単一のチャンネルレイアウトで動作しているため、もしこのような変更前の異なるチャンネル数のサンプルを受け取った場合、それらは新しく受け取られた入力と結合される前にアップミックスまたはダウンミックスされなくてはなりません ( MUST )。

注 :定義により DelayNode は、遅延の量に等しいオーディオ処理レイテンシをもたらします。

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

DelayNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

delayTime, AudioParam 型, readonly

適用する遅延 ( 単位は秒 ) の量を表す AudioParam オブジェクトです。 デフォルトの value は 0 ( 遅延なし ) です。 最小の値は 0 で最大の値は AudioContext の createDelay() メソッドの引数 maxDelayTime または コンストラクタ の DelayOptions の maxDelayTime メンバーで決定されます。

もし DelayNode が 循環 の一部である場合、delayTime 属性の最小値は 1 レンダリング量子 にクランプされます。

これは、DelayNode を生成するオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合、ノードは通常のデフォルトを使用して生成されます。

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

delayTime, double 型, デフォルト値は 0

ノードの遅延時間の初期値です。

maxDelayTime, double 型, デフォルト値は 1

ノードの最大遅延時間です。 制約については createDelay(maxDelayTime) を参照してください。

DelayNode は delayTime 秒のオーディオを保持する内部バッファを持っています。

DelayNode の処理は、遅延ラインへの書き込みと遅延ラインからの読み取りの 2 つの部分に分かれています。 これは 2 つの内部的な AudioNode を介して行われます（開発者が使用するものではなく、ノードの内部動作の説明を簡単にするためのものです）。 これらはどちらも DelayNode によって作成されます。

DelayNode の DelayWriter を作成するということは、AudioNode と同じインタフェースを持ち、DelayNode の内部バッファに入力オーディオを書き込むオブジェクトを作成することを意味します。 基となる DelayNode と同じ入力の接続を持ちます。

DelayNode の DelayReader を作成するということは、AudioNode と同じインタフェースを持ち、DelayNode の内部バッファからオーディオデータを読み取ることができるオブジェクトを作成することを意味します。 基となる DelayNode と同じ AudioNode に接続されます。 DelayReader は ソースノード です。

入力バッファを処理するとき、DelayWriter はオーディオを DelayNode の内部バッファに書き込まなくてはなりません ( MUST )。

出力バッファを生成するとき、DelayReader は対応する DelayWriter が delayTime 秒前に書き込まれたオーディオを正確に生成しなくてはなりません ( MUST )。

注 :これは、チャンネル数の変更は遅延時間が経過した後に反映されることを意味します。

DynamicsCompressorNode は、ダイナミクスコンプレッション効果を実装した AudioNode です。

ダイナミクス・コンプレッションは音楽制作やゲーム・オーディオで非常に良く使用されます。 これは信号の音量が大きな部分を抑え、音量が小さな部分を持ち上げます。 全体として、より大きく、豊かで隙間のない音を作る事ができます。 これは特に、多くの個別サウンドを同時に再生するゲームと音楽アプリケーションで、全体の信号レベルを制御してスピーカーへの出力のクリッピング ( 歪み ) を避けるために重要です。

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

DynamicsCompressorNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

[[internal reduction]] を、デシベル単位の浮動小数点数を保持する this の内部スロットとします。 [[internal reduction]] を 0.0 に設定します。

attack, AudioParam 型, readonly

ゲインを 10dB 下げるために必要な時間 ( 単位は秒 ) です。

knee, AudioParam 型, readonly

スレッショルドより上の一定の範囲を表すデシベル値で、この範囲で "ratio" に曲線で滑らかに移行します。

ratio, AudioParam 型, readonly

出力が 1dB 変化する事に対する入力の dB 変化量です。

reduction, float 型, readonly

メーター表示のための読み取り専用のデシベル値であり、コンプレッサーが現在信号に適用しているゲインリダクションの量を表します。 信号が入力されていない場合、値は 0 ( ゲイン減少なし ) になります。 この属性が読み取られると、内部スロット [[internal reduction]] の値を返します。

release, AudioParam 型, readonly

ゲインを 10dB 上げるために必要な時間 ( 単位は秒 ) です。

threshold, AudioParam 型, readonly

この値以上でコンプレッションを開始する dB 値です。

これは DynamicsCompressorNode の生成に使用するオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合、通常のデフォルトがノードの生成に使用されます。

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

attack, float 型, デフォルト値は 0.003

attack AudioParam の初期値です。

knee, float 型, デフォルト値は 30

knee AudioParam の初期値です。

ratio, float 型, デフォルト値は 12

ratio AudioParam の初期値です。

release, float 型, デフォルト値は 0.25

release AudioParam の初期値です。

threshold, float 型, デフォルト値は -24

threshold AudioParam の初期値です。

ダイナミクスコンプレッションはさまざまな方法で実装できますが、DynamicsCompressorNode は、次の特性を持つダイナミクスプロセッサを実装しています :

• 固定長の先読みを行います ( これは、DynamicsCompressorNode が信号チェーンに固定のレイテンシを追加することを意味します )。

• アタック速度、リリース速度、スレッショルド、ニー特性、およびレシオを設定可能とします。

• サイドチェインはサポートされません。

• ゲインリダクションは、DynamicsCompressorNode の reduction プロパティを 介して レポートされます。

• 圧縮カーブは 3 つの部分からなります:

  • 最初のパートは入力と同一です : \(f(x) = x\)。

  • 二番目のパートはソフトニー部分で、単調増加関数でなくてはなりません ( MUST )。

  • 三番目のパートは線形関数です : \(f(x) = \frac{1}{ratio} \cdot x \)。

  この曲線は、連続的かつ区分的に微分可能であり、入力レベルに基づいて目標とする出力レベルに対応したものでなければなりません ( MUST )。

この曲線を図示すると次のようになります :

内部的には、DynamicsCompressorNode は、他の AudioNode とゲイン低減値を計算するための特別なアルゴリズムの組み合わせで記述されています。

下の AudioNode グラフが内部で使用されています。 input と output はそれぞれ、AudioNode の入力と出力、context はこの DynamicsCompressorNode の BaseAudioContext コンテキスト、そして以下の通り AudioNode のように動作する特殊オブジェクトをインスタンス化する新しいクラス EnvelopeFollower です :

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

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

注 : これはプリディレイとゲインリダクションの適用について実装しています。

以下のアルゴリズムは、ゲイン低減値を生成するために入力信号に適用される エンベロープフォロワー オブジェクトによって実行される処理を記述しています。 エンベロープフォロワー には、浮動小数点値を保持する 2 つのスロットがあります。 これらの値は、このアルゴリズムの呼び出し間で維持されます。

• [[detector average]] を浮動小数点の値とし、0.0 に初期化します。

• [[compressor gain]] を浮動小数点の値とし、1.0 に初期化します。

以下のアルゴリズムにより、オーディオのレンダリング量子の入力の各サンプルについて、

の値を決定することができます。

1. attack と release は、それぞれ処理時に ( k-rate パラメータとして ) サンプリングされた attack と release の値に、この DynamicsCompressorNode が 関連付け られている BaseAudioContext のサンプルレートを乗算されています。

2. ディテクター平均 をスロット [[detector average]] の値とします。

3. コンプレッサーゲイン をスロット [[compressor gain]] の値とします。

4. 処理されるレンダリング量子の各サンプル input ごとに、以下の手順を実行します :

   1. input の絶対値が 0.0001 未満の場合は、減衰率は 1.0 です。 そうでない場合、shaped input を input の絶対値に 圧縮カーブ を適用した値とします。 減衰率 は shaped input を input の絶対値で割った値とします。

   2. 減衰率 が コンプレッサーゲイン よりも大きい場合は、リリース状態 を true とし、それ以外の場合は false とします。

   3. ディテクターレート を 減衰率 に ディテクターカーブ を適用した結果とします。

   4. ディテクター平均 を 減衰率 から減算し、その結果に ディテクターレート を掛けます。 そしてこの新しい結果を ディテクター平均 に加えます。

   5. ディテクター平均 は最大 1.0 にクランプされます。

   6. エンベロープ速度 は、attack と release の値に基づいて エンベロープ速度の計算 を行った結果とします。

   7. もし リリース状態 が true である場合、コンプレッサーゲイン を コンプレッサーゲイン に エンベロープ速度 を乗じた値に設定し、最大 1.0 にクランプします。

   8. そうでなく、リリース状態 が false の場合、ゲイン増分 を ディテクター平均 から コンプレッサーゲイン を引いたものにします。 ゲイン増分 に エンベロープ速度 を掛け、その結果を コンプレッサーゲイン に加算します。

   9. コンプレッサーゲイン に メイクアップゲインの計算 の戻り値を掛けて、リダクションゲイン を計算します。

   10. メーターゲイン は リダクションゲイン を デシベルに変換 したものとします。

5. [[compressor gain]] を コンプレッサーゲイン に設定します。

6. [[detector average]] を ディテクター平均 に設定します。

7. 内部スロット [[internal reduction]] を メーターゲイン の値に アトミック に設定します。

   注 : この手順は、ブロックの処理ごとに一度、処理の最後にメーターゲインを更新します。

メイクアップゲインは、コンプレッサーのレシオ、ニー、およびスレッショルドパラメータにのみ依存する固定された増幅ステージで入力信号には依存しません。 この目的は、コンプレッサーの出力レベルを入力レベルと同程度に高めることです。

は以下の手順の実行を意味します :

1. フルレンジゲイン は、値 1.0 に 圧縮カーブ を適用することによって返される値とします。

2. フルレンジメイクアップゲイン は フルレンジゲイン の逆数とします。

3. フルレンジメイクアップゲイン の 0.6 乗の結果を返します。

は、

と

の比に関数を適用することによって行われます。 ユーザーエージェントは、エンベロープ関数の形状を選択することができます。 ただし、この関数は次の制約を遵守しなければなりません ( MUST ) :

• エンベロープ速度は、コンプレッサーゲイン と ディテクター平均 の比から計算しなければなりません ( MUST )。

  注 :アタックのときには、この数値は 1 以下で、リリースのときにはこの数値は 1 よりも大きくなります。

• アタックの曲線は \([0, 1]\) の範囲で連続した単調増加関数でなければなりません ( MUST )。 この曲線の形は attack によって制御される場合もあります ( MAY )。

• リリースの曲線は、常に 1 より大きい連続的で単調減少関数でなければなりません ( MUST )。 この曲線の形状は、release によって制御される場合もあります ( MAY )。

この処理は、コンプレッサーゲイン と ディテクター平均 の比に関数を適用して計算された値を返します。

アタックまたはリリース時の変化率に ディテクターカーブ を適用すると、適応型リリース の実装が可能になります。 関数は次の制約を守らなければなりません ( MUST ) :

• 関数の出力は \([0,1]\) の範囲でなくてはなりません ( MUST )。

• 関数は連続で単調増加でなくてはなりません ( MUST )。

注 :例えば 適応型リリース を実行して、リリースが速くてコンプレッションが遅いコンプレッサー、あるいは、アタックとリリースのカーブの形状が同じではないコンプレッサーも可能です。

値に

を適用するとは、サンプルが関数に渡され、計算された値が返される事を意味します。 この関数は次の特性を持たなくてはなりません ( MUST ) :

1. threshold および knee は、threshold および knee の値をそれぞれ リニア値に変換 して、このブロックの処理時に ( k-rate パラメータとして ) サンプリングされた値とします。

2. このブロックの処理時に（ k-rate パラメータとして ）サンプリングされた threshold と knee の合計を計算します。

3. knee end threshold はこの合計を リニア値に変換 した値とします。

4. ratio は、このブロックの処理時に ( k-rate パラメータとして ) サンプリングされた ratio の値とします。

5. この関数は、threshold の値までは直線的で同一 ( すなわち、 \(f(x) = x\) ) です。

6. threshold から knee end threshold までは、ユーザーエージェントは曲線の形状を選択できます。 関数全体は単調に増加し、連続的でなければなりません。

   注 :knee が 0 の場合、DynamicsCompressorNode はハードニーコンプレッサーと呼ばれます。

7. threshold とソフトニーの後、この関数は ratio に基づく直線の関数 ( すなわち、\(f(x) = \frac{1}{ratio} \cdot x \)) となります。

リニアの値 \(v\) を

するとは、次の手順を実行することを意味します :

1. もし \(v\) がゼロならば -1000 を返します。

2. そうでなければ \( 20 \, \log_{10}{v} \) を返します。

デシベルの値 \(v\) を リニアの値に変換 する事は \(10^{v/20}\) を返すことを意味します。

オーディオ信号のゲインを変える事はオーディオアプリケーションでは基本的な処理です。 このインタフェースは 1 つの信号入力と 1 つの信号出力を持つ AudioNode です :

GainNode の入力データの各チャンネルの各サンプルは gain AudioParam の computedValue が乗じられます ( MUST )。

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

GainNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

gain, AudioParam 型, readonly

適用される増幅度の大きさを表します。

これは GainNode の作成に使用するオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合は、通常のデフォルトがノードの作成に使用されます。

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

gain, float 型, デフォルト値は 1.0

gain AudioParam の初期値です。

IIRFilterNode は汎用の IIR フィルタ を実装した AudioNode です。 一般的には高次のフィルタについては次のような理由で BiquadFilterNode を利用するのが最善です :

• 一般的に数値的な問題に関して敏感ではありません

• フィルタのパラメータがオートメーションできます

• すべての偶数次 IIR フィルタの作成に使用できます

しかしながら奇数次フィルタは作成できず、もしそのようなフィルタが必要な場合やオートメーションが不要ならば IIR フィルタが適切かもしれません。

一度作成された後、IIR フィルタの係数は変更する事ができません。

出力のチャンネル数は常に入力のチャンネル数と同じになります。

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

IIRFilterNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出される場合、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

getFrequencyResponse(frequencyHz, magResponse, phaseResponse)

与えられた現在のフィルタパラメータの設定で、指定された周波数の周波数応答を同期的に計算します。 3 つのパラメータは、同じ長さの Float32Array でなければならず ( MUST )、そうでなければ InvalidAccessError を発生します ( MUST )。

IIRFilterNode.getFrequencyResponse() メソッドの引数 パラメータ 型 Null可 省略可 説明 frequencyHz Float32Array ✘ ✘ このパラメータは、応答を計算する周波数の配列を Hz で指定します。 magResponse Float32Array ✘ ✘ このパラメータは、リニア振幅応答の出力結果を受け取る配列を指定します。 もし frequencyHz パラメータの値が [0, sampleRate / 2] の範囲にない場合 ( ここで sampleRate は AudioContext の sampleRate プロパティの値です )、magResponse 配列の同じインデックスの対応する値は NaN にならなくてはなりません ( MUST )。 phaseResponse Float32Array ✘ ✘ このパラメータは、ラジアンで出力される位相応答値を受け取る配列を指定します。 もし frequencyHz パラメータの値が [0; sampleRate / 2] の範囲にない場合 ( ここで、sampleRate は AudioContext の sampleRate プロパティの値です )、phaseResponse 配列の同じインデックスの対応する値は NaN にならなくてはなりません ( MUST )。

IIRFilterOptions ディクショナリは、IIRFilterNode のフィルタ係数を指定するために使用されます。

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

feedforward, sequence<double> 型

IIRFilterNode のフィードフォワード係数です。 このメンバーは必須です。 他の制約については、createIIRFilter() の feedforward 引数を参照してください。

feedback, sequence<double> 型

IIRFilterNode のフィードバック係数です。 このメンバーは必須です。 他の制約については、createIIRFilter() の feedback 引数を参照してください。

createIIRFilter() または コンストラクタ の IIRFilterOptions ディクショナリで指定される feedforward 係数を \(b_m\) feedback 係数を \(a_n\) とします。 すると一般的な IIR フィルタの 伝達関数は次のように与えられます。

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

ここで \(M + 1\) は \(b\) 配列の長さ、\(N + 1\) は \(a\) 配列の長さです。 係数 \(a_0\) は 0 であってはいけません ( MUST ) ( createIIRFilter() の feedback parameter を参照してください )。 \(b_m\) の少なくとも 1 つは 非 0 でなくてはなりません ( MUST ) ( createIIRFilter() の feedforward parameter を参照してください )。

同じように、時間領域の式については :

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

フィルタの初期状態は、全てゼロ状態です。

注 :UAは、フィルタの状態に NaN 値が発生したことをユーザーに通知する警告を出す場合があります。 これは通常、不安定なフィルタを示しています。

このインタフェースは audio または video 要素からの音声ソースを表します。

出力のチャンネル数は HTMLMediaElement で参照されるメディアのチャンネル数に対応します。 そのため、メディア要素の src 属性を変更する事によって、このノードの出力のチャンネル数が変化します。

HTMLMediaElement のサンプルレートが、関連する AudioContext のサンプルレートと異なる場合、HTMLMediaElement からの出力は、コンテキストの サンプルレート と一致するようにリサンプリングされなくてはなりません。

MediaElementAudioSourceNode は、AudioContext の createMediaElementSource() メソッドまたは コンストラクタ で MediaElementAudioSourceOptions ディクショナリの mediaElement メンバーにより、HTMLMediaElement を指定して作成されます。

1つだけある出力のチャネル数は createMediaElementSource() への引数として渡された HTMLMediaElement によって参照されるオーディオのチャネル数に等しい、あるいは HTMLMediaElement がオーディオをもっていない場合は 1 になります。

HTMLMediaElement は MediaElementAudioSourceNode が作成された後、オーディオが直接音として再生されなくなる代わりに MediaElementAudioSourceNode からルーティンググラフを通して再生されるようになる事を 除けば、全く同じに振る舞わなくてはなりません ( MUST )。 つまり、ポーズ、シーク、ボリューム、src 属性の変更、その他 HTMLMediaElement としての見掛けは MediaElementAudioSourceNode を使用して いない 場合と同様に通常どおり働かなくてはなりません ( MUST )。

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

[Exposed=Window]
interface MediaElementAudioSourceNode : AudioNode {
    constructor (AudioContext context, MediaElementAudioSourceOptions options);
    [SameObject] readonly attribute HTMLMediaElement mediaElement;
};

MediaElementAudioSourceNode(context, options)

1. context と options を引数として AudioNode this を 初期化 します。

mediaElement, HTMLMediaElement 型, readonly

この MediaElementAudioSourceNode を生成する際に使用される HTMLMediaElement です。

MediaElementAudioSourceNode を生成する際のオプションを指定するために使用されます。

dictionary MediaElementAudioSourceOptions {
    required HTMLMediaElement mediaElement;
};

mediaElement, HTMLMediaElement

再ルーティングされるメディア要素です。 この指定は必須です ( MUST )。

HTMLMediaElement はクロスオリジン・リソースの再生が可能です。 Web Audio はリソースの内容の検査が、( 例えば MediaElementAudioSourceNode や AudioWorkletNode や ScriptProcessorNode を使ってサンプルを読む事で ) 可能なので、もしある origin からのスクリプトが別の origin からのリソースの内容を検査する事で情報の漏洩が起こり得ます。

これを防ぐために MediaElementAudioSourceNode は、フェッチアルゴリズム [FETCH] の実行によってリソースが CORS-cross-origin としてラベル付けされた HTMLMediaElement を使用して作成された場合、HTMLMediaElement の通常の出力の代わりに 無音 を出力する必要があります ( MUST )。

このインタフェースは kind が "audio" の 1 つの MediaStreamTrack を持つ MediaStream を表すオーディオの出力地点となります。 この MediaStream は、ノードが作成された時点で作られ、stream 属性を通じてアクセスする事ができます。 このストリームは、getUserMedia() によって得られた MediaStream と同様の方法で使う事ができ、例えば、 RTCPeerConnection ( [webrtc] で説明されています ) の addStream() メソッドを使って、リモートピアに送る事ができます。

入力のチャンネル数はデフォルトで 2 (ステレオ)です。

[Exposed=Window]
interface MediaStreamAudioDestinationNode : AudioNode {
    constructor (AudioContext context, optional AudioNodeOptions options = {});
    readonly attribute MediaStream stream;
};

MediaStreamAudioDestinationNode(context, options)

1. context と options を引数として AudioNode this を 初期化 します。

stream, MediaStream 型, readonly

ノード自身と同じチャンネル数の 1 つの MediaStreamTrack を持ち、その kind 属性は "audio" である MediaStream です。

このインタフェースは MediaStream からのオーディオソースを表します。

出力のチャンネル数は MediaStreamTrack のチャンネル数に対応します。 MediaStreamTrack が終了すると、この AudioNode の出力は 1 チャンネルの無音となります。

MediaStreamTrack のサンプルレートが、関連する AudioContext のサンプルレートと異なる場合、 MediaStreamTrack の出力は、コンテキストの サンプルレート に一致するようにリサンプリングされます。

[Exposed=Window]
interface MediaStreamAudioSourceNode : AudioNode {
    constructor (AudioContext context, MediaStreamAudioSourceOptions options);
    [SameObject] readonly attribute MediaStream mediaStream;
};

MediaStreamAudioSourceNode(context, options)

1. options の mediaStream メンバーが、 kind 属性の値が "audio" である MediaStreamTrack が少なくとも 1 つある MediaStream を参照していない場合は、InvalidStateError を発生し、これらの手順を中止します。 そうでない場合は、このストリームを inputStream とします。

2. tracks を kind が "audio" である inputStream のすべての MediaStreamTrack のリストとします。

3. tracks の要素を id 属性の コードユニット 値の順序に基づいてソートします。

4. context と options を引数として AudioNode this を 初期化 します。

5. この MediaStreamAudioSourceNode の内部スロット [[input track]] を tracks の最初の要素とします。 これがこの MediaStreamAudioSourceNode の入力オーディオとして使用されるトラックになります。

構築後に、コンストラクタに渡された MediaStream に変更を加えても、この AudioNode の出力に影響を与えません。

スロット [[input track]] は、MediaStreamTrack への参照を維持するためにのみ使用されます。

注 :これは MediaStreamAudioSourceNode のコンストラクタによって選択されたトラックをこのコンストラクタに渡された MediaStream から削除しても、MediaStreamAudioSourceNode は同じトラックから入力を取得し続けることを意味します。

注 :歴史的な理由により、出力するトラックをどのように選択するかは任意です。 代わりに MediaStreamTrackAudioSourceNode を使用すると、入力として使用するトラックを明示的に選択できます。

mediaStream, MediaStream 型, readonly

この MediaStreamAudioSourceNode を構築するときに使用される MediaStream です。

MediaStreamAudioSourceNode を構築するためのオプションを指定します。

dictionary MediaStreamAudioSourceOptions {
    required MediaStream mediaStream;
};

mediaStream, MediaStream 型

ソースとなるメディアストリームです。 これは必須になります ( MUST )。

このインタフェースは MediaStreamTrack からの音源を表します。

出力のチャンネル数は mediaStreamTrack のチャンネル数に対応したものになります。

MediaStreamTrack のサンプルレートが、関連する AudioContext のサンプルレートと異なる場合、mediaStreamTrack の出力は、コンテキストの サンプルレート に一致するようにリサンプリングされます。

[Exposed=Window]
interface MediaStreamTrackAudioSourceNode : AudioNode {
    constructor (AudioContext context, MediaStreamTrackAudioSourceOptions options);
};

MediaStreamTrackAudioSourceNode(context, options)

1. mediaStreamTrack の kind 属性が "audio" でない場合は、InvalidStateError を発生し、これらの手順を中止します。

2. context と options を引数として AudioNode this を 初期化 します。

MediaStreamTrackAudioSourceNode を構築するためのオプションを指定します。 これは必須になります。

dictionary MediaStreamTrackAudioSourceOptions {
    required MediaStreamTrack mediaStreamTrack;
};

mediaStreamTrack, MediaStreamTrack 型

音源となるメディアストリームトラックです。 この MediaStreamTrack の kind 属性が "audio" でない場合 InvalidStateError を発生します ( MUST )。

OscillatorNode は周期的な波形を発生するオーディオソースを表しています。 これは一般的に使われるいくつかの波形に設定する事ができます。 さらにこれは PeriodicWave オブジェクトを使って任意の周期波形に設定する事が可能です。

オシレーターは音の合成において一般的な基本構成ブロックです。 OscillatorNode は start() メソッドで指定された時刻に音の発生を開始します。

数学的に言えば、連続した時間 の周期波形は周波数領域で考えた場合、非常に高い ( あるいは無限に高い ) 周波数情報を持つ事ができます。 この波形があるサンプルレートの離散時間のデジタルオーディオ信号としてサンプリングされる場合、波形をデジタル化する前に ナイキスト周波数 よりも高い高周波数成分の除去 ( フィルタで取り除く事 ) を考慮しなくてはなりません ( MUST )。 これを行わない場合、( ナイキスト周波数 よりも ) 高い周波数の エイリアス が ナイキスト周波数 よりも低い周波数に鏡像として折り返されます。 多くの場合、これは音として聴こえる好ましくないノイズを引き起こします。 これはオーディオ DSP における基本的で良く知られている原理です。

このエイリアスを避けるため、実装に使う事のできるいくつかの実践的な手段があります。 しかしこれらの手段によらず、理想的 な離散時間のデジタルオーディオ信号は数学的には完全に定義されます。 ( CPU の負荷という意味で) 実装のコスト対、理想への忠実性というトレードオフが実装上の問題になります。

実装はこの理想を達成するためにいくらかの考慮をする事が期待されますが、ローエンドのハードウェアでは低品質ローコストな手段を考慮する事も合理的です。

frequency と detune はどちらも a-rate パラメータで、複合パラメータ となります。 これらは computedOscFrequency の値を決定するために組み合わされて使用されます:

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

OscillatorNode の各時刻での瞬間的な位相は、ノードの正確なスタート時刻において位相角をゼロとして computedOscFrequency を時間で積分したものになります。 その 公称範囲 は [-ナイキスト周波数, ナイキスト周波数] となります。

このノードの出力は 1 つだけで、1 つのチャネル (モノラル) で構成されます。

enum OscillatorType {
    "sine",
    "square",
    "sawtooth",
    "triangle",
    "custom"
};

[Exposed=Window]
interface OscillatorNode : AudioScheduledSourceNode {
    constructor (BaseAudioContext context, optional OscillatorOptions options = {});
    attribute OscillatorType type;
    readonly attribute AudioParam frequency;
    readonly attribute AudioParam detune;
    undefined setPeriodicWave (PeriodicWave periodicWave);
};

OscillatorNode(context, options)

コンストラクタが BaseAudioContext c とオプションオブジェクト option を指定して呼び出された時、ユーザーエージェントは context と options を引数として AudioNode this を 初期化 しなくてはなりません ( MUST )。

detune, AudioParam 型, readonly

( セント で表される ) デチューン値で、これは frequency を与えられた量だけオフセットします。 デフォルトの value は 0 です。 このパラメータは a-rate です。 これは frequency と組み合わせて 複合パラメータ となり、computedOscFrequency を決定します。 下の表で示される公称範囲により、このパラメータを使用して frequency を可能な周波数範囲全体にわたってデチューンすることができます

frequency, AudioParam 型, readonly

( Hz:ヘルツで表される ) 周期波形の周波数で、そのデフォルトの value は 440 です。 このパラメータは a-rate です。 これは detune と組み合わされて 複合パラメータ となり、computedOscFrequency を構成します。 その 公称範囲 は [-ナイキスト周波数, ナイキスト周波数] です。

type, OscillatorType 型

周期波形の形状です。 "custom" 以外の波形の定数値は直接設定する事ができます。 "custom" の場合は InvalidStateError 例外を発生します ( MUST )。 カスタム波形を設定するには setPeriodicWave() メソッドを使用する事ができ、それによってこの属性は "custom" に設定されます。 デフォルト値は "sine" です。 属性が設定されたとき、オシレーターの位相は保存されなくてはなりません ( MUST )。

setPeriodicWave(periodicWave)

PeriodicWave で与えられる任意のカスタム周期波形を設定します。

これは OscillatorNode を作成するときに使用されるオプションを指定します。 すべてのメンバーはオプションです。 指定されていない場合、通常のデフォルト値がオシレーターの作成に使用されます。

dictionary OscillatorOptions : AudioNodeOptions {
    OscillatorType type = "sine";
    float frequency = 440;
    float detune = 0;
    PeriodicWave periodicWave;
};

detune, float 型, デフォルト値は 0

OscillatorNode の detune の初期値です。

frequency, float 型, デフォルト値は 440

OscillatorNode の frequency の初期値です。

periodicWave, PeriodicWave

OscillatorNode の PeriodicWave です。 もしこれが指定されているならば、type に有効な値が設定されていても無視され、"custom" が指定されたように処理されます。

type, OscillatorType 型, デフォルト値は "sine"

生成するオシレーターのタイプです。 これが periodicWave を指定せずに "custom" に設定されている場合、InvalidStateError 例外を発生します ( MUST )。 periodicWave が指定されている場合、type に有効な値があっても無視され、"custom" に設定されているかのように扱われます。

様々なオシレーターのタイプのための理想的な数学的波形をここで定義します。 概要としてはすべての波形は時間 0 のときに正の傾きを持つ奇関数として数学的に定義されます。 実際にオシレーターで生成される波形はエイリアシングの影響を避けるため少し異なったものになります。

オシレーターは、適切な フーリエ級数 で、disableNormalization を false に設定した PeriodicWave を使用してこれらの基本波形を作成した場合と同じ結果を生成しなくてはなりません ( MUST )。

"sine"

サイン波のオシレーター波形は :

$$
    x(t) = \sin t
$$

"square"

矩形波のオシレーター波形は :

$$
    x(t) = \begin{cases}
                 1 & \mbox{for } 0≤ t < \pi \\
                 -1 & \mbox{for } -\pi < t < 0.
                 \end{cases}
$$

これは、波形が周期 \(2\pi\) の奇関数であることを利用して、すべての \(t\) に拡張されます。

"sawtooth"

鋸歯状波オシレーターの波形は上昇波形です :

$$
    x(t) = \frac{t}{\pi} \mbox{ for } -\pi < t ≤ \pi;
$$

これは、波形が周期 \(2\pi\) の奇関数であることを利用して、すべての \(t\) に拡張されます。

"triangle"

三角波オシレーターの波形は :

$$
    x(t) = \begin{cases}
                     \frac{2}{\pi} t & \mbox{for } 0 ≤ t ≤ \frac{\pi}{2} \\
                     1-\frac{2}{\pi} \left(t-\frac{\pi}{2}\right) & \mbox{for }
                     \frac{\pi}{2} < t ≤ \pi.
                 \end{cases}
$$

これは、波形が周期 \(2\pi\) の奇関数であることを利用して、すべての \(t\) に拡張されます。

このインタフェースは、入力オーディオストリームを 3 次元空間に 配置 / 空間化 する処理ノードを表します。 空間化は、 BaseAudioContext の AudioListener ( listener 属性 ) に関連しています。

このノードの入力は、モノラル ( 1 チャンネル ) またはステレオ ( 2 チャンネル ) のいずれかであり、増加させることはできません。 より少ないまたは多いチャンネルを持つノードからの接続は、適切にアップミックスまたはダウンミックス されます。

もしノードが アクティブに処理 されている場合、このノードの出力はステレオ ( 2 チャンネル ) に固定されており、変更する事はできません。 もしノードが アクティブに処理 されていない場合、出力は 1 チャンネルの無音となります。

PanningModelType 列挙値は 3D 空間でのオーディオの定位にどのアルゴリズムを使用するかを決定します。 デフォルトは "equalpower" です。

enum PanningModelType {
        "equalpower",
        "HRTF"
};

注 :このパンニングモデルを使用すると、このノードの出力を計算するために使用されるすべての AudioParam は a-rate になります。

注 :このパンニングモデルを使用すると、このノードの出力を計算するために使用されるすべての AudioParam は k-rate になります。

PannerNode の AudioParam の 有効なオートメーション速度 は panningModel と AudioParam の automationRate によって決まります。 panningModel が "HRTF" の場合、有効なオートメーション速度 は automationRate の設定とは無関係に "k-rate" になります。 それ以外の場合、有効なオートメーション速度 は automationRate の値になります。

DistanceModelType 列挙値は 音源がリスナーから離れていったとき、音量を減衰させるためにどのアルゴリズムを使用するかを決定します。 デフォルトは "inverse" です。

次のそれぞれの距離モデルの説明で、\(d\) はリスナーとパンナーの距離、\(d_{ref}\) は refDistance 属性の値、\(d_{max}\) は maxDistance 属性の値、\(f\) は rolloffFactor の値です。p>

enum DistanceModelType {
    "linear",
    "inverse",
    "exponential"
};

$$
    1 - f\ \frac{\max\left[\min\left(d, d'_{max}\right), d'_{ref}\right] - d'_{ref}}{d'_{max} - d'_{ref}}
$$

ここで \(d'_{ref} = \min\left(d_{ref}, d_{max}\right)\) 、 \(d'_{max} = \max\left(d_{ref}, d_{max}\right)\) とします。 \(d'_{ref} = d'_{max}\) の場合は、直線距離モデルが取る値は \(1-f\).