retrotalk 2.1.0

package/src/talk_audio.js

@@ -0,0 +1,275 @@
+// SPDX-FileCopyrightText: 2026 harayoki
+// SPDX-License-Identifier: MIT
+
+// 音声の登録と再生を扱います。SimpleAudio を継承しています。
+//
+// 波形そのものは talk.js の renderTalk() が作ります。このファイルが行うのは、
+// テキストに名前を付けて覚えること、作った波形を保持すること、
+// 空きを確保して再生することの 3 つです。
+
+import { SimpleAudio } from './simple_audio.js';
+import { renderTalk } from './talk.js';
+import { checkTalk } from './kana.js';
+import { checkAqua } from './aquestalk.js';
+
+/**
+ * `talk()` が内部で作る名前の印。人が書く名前とは重ならない
+ * @private
+ */
+const AUTO_TALK = '\u0000talk:';
+
+/**
+ * RetroTalk の入口です。読み込むと `MmsxxRetroTalk` という名前で使えます。
+ *
+ * 音声の登録と再生を扱います。`SimpleAudio` を継承しているので、
+ * 音量と消音の操作もここから行えます。
+ *
+ * @extends SimpleAudio
+ * @example
+ * const voice = new MmsxxRetroTalk(new AudioContext());
+ * voice.talk('コンニチワ');
+ */
+export class TalkAudio extends SimpleAudio {
+  /**
+   * @param {AudioContext} ctx 呼び出し側で作った AudioContext
+   * @param {object} [opts]
+   * @param {number} [opts.maxVoices=8] 同時に再生できる音の数
+   * @param {number} [opts.maxTalk=1] 同時に再生できるセリフの数
+   */
+  constructor(ctx, opts = {}) {
+    super(ctx, opts);
+    /** 登録したテキスト。音声ファイルは持たず、再生時に波形を作ります */
+    this.talkDefs = new Map();
+    /**
+     * 同時に再生できるセリフの数。
+     *
+     * 重なると聞き取れないため、初期値は 1 です。
+     * 複数の人物が同時に話す場面では増やします。
+     *
+     * @type {number}
+     */
+    this.maxTalk = opts.maxTalk ?? 1;
+    // `talk()` が使い捨ての名前を作るための番号
+    this._talkSeq = 0;
+  }
+
+  /**
+   * テキストに名前を付けて登録します。再生はしません。
+   *
+   * 同じテキストを何度も再生するときに使います。作った波形は名前ごとに
+   * 保持するので、2 回目以降は作り直しません。
+   *
+   * `@` で始まる指示をテキストに混ぜられます。指示はそこから後ろに効きます。
+   *
+   *   `@p<Hz>`  声の高さ。例 `@p200`
+   *   `@s<%>`   話す速さ。例 `@s150`（1.5 倍）
+   *   `@v<0-15>` 音量。例 `@v8`
+   *
+   * ```js
+   * voice.defineTalk('two', 'ワタシデス。@p180 イエ、ワタシデス。');
+   * ```
+   *
+   * 抑揚は句読点（`、` `。`）で元に戻ります。文全体で少しずつ下がるため、
+   * 切れ目が無いと長い文の終わりで音が沈みます。空白では戻りません。
+   *
+   * @param {string} name 登録名
+   * @param {string} text カタカナ。空白と句読点は間になります
+   * @param {object} [opts]
+   *   音声のパラメータ。一覧は `renderTalk()` の説明にあります。
+   *   `unknown` は読めない文字が混ざったときの扱いで、
+   *   `warn`（初期値）/ `error` / `ignore` から選びます
+   * @returns {void}
+   */
+  defineTalk(name, text, opts = {}) {
+    // 読めない文字は登録した時点で知らせる。再生してから
+    // 「そこだけ抜けた」と気づくのでは遅い
+    const how = opts.unknown ?? 'warn';
+    if (how !== 'ignore') {
+      // アクセント記号列で渡すときは、記号を除いてから調べる。
+      // VOICEVOX の読みは JSON なので、文字として調べても意味が無い
+      const got = opts.format === 'voicevox' ? { ok: true, unknown: [] }
+        : opts.format === 'aquestalk' ? checkAqua(text) : checkTalk(text);
+      if (!got.ok) {
+        const what = got.unknown.slice(0, 8).map((u) => u.ch).join(' ');
+        const more = got.unknown.length > 8 ? ` ほか ${got.unknown.length - 8} 字` : '';
+        // 内部で作った名前は読めないので、テキストのほうを出す
+        const label = name.startsWith(AUTO_TALK) ? text : name;
+        const say = `[RetroTalk] talk "${label}": 読めない字があります — ${what}${more}`
+          + '(漢字と数字は読みにしてから渡します)';
+        if (how === 'error') throw new Error(say);
+        console.warn(say);
+      }
+    }
+    this.talkDefs.set(name, { text, opts, buffer: null });
+  }
+
+  /**
+   * テキストをその場で再生します。
+   *
+   * `defineTalk()` と `playTalk()` をまとめて行う短い書き方です。
+   *
+   * ```js
+   * voice.talk('コンニチワ');
+   * ```
+   *
+   * 登録は残らないので、作った波形も保持しません。同じテキストを
+   * 繰り返し再生するなら `defineTalk()` で名前を付けてください。
+   *
+   * @param {string} text カタカナ。`defineTalk()` と同じ
+   * @param {object} [opts] 音声のパラメータ。`defineTalk()` と同じ
+   * @param {number} [priority=0] `playTalk()` と同じ
+   * @returns {number|undefined} 再生 ID。再生できなかったときは undefined
+   */
+  talk(text, opts = {}, priority = 0) {
+    const name = AUTO_TALK + (++this._talkSeq);
+    this.defineTalk(name, text, opts);
+    const id = this.playTalk(name, priority, opts);
+    // 再生を始めたら登録を消す。波形は再生側が参照しているので最後まで鳴る。
+    // 消さないと、名前の分からないものが溜まり続けて捨てられなくなる
+    this.talkDefs.delete(name);
+    return id;
+  }
+
+  /**
+   * 読み上げられない文字を調べます。再生はしません。
+   *
+   * 登録する前に確かめるときに使います。読めない文字がテキストのどこにあるかも返します。
+   *
+   * ```js
+   * const got = voice.checkTalk('今日は 3ガツ デス');
+   * // { ok: false, kana: 6, unknown: [{ ch: '今', at: 0, kind: 'kanji' }, ...] }
+   * ```
+   *
+   * @param {string} text 調べるテキスト
+   * @returns {{ok: boolean, kana: number,
+   *            unknown: Array<{ch: string, at: number, kind: string}>}}
+   *   `ok` は読めない文字が無ければ true、`kana` は読めた文字数、
+   *   `at` はテキスト内の位置、`kind` は文字の種別
+   */
+  checkTalk(text) {
+    return checkTalk(text);
+  }
+
+  /**
+   * 波形の生成だけを行います。再生はしません。
+   *
+   * `playTalk()` は初回に波形を生成するため、その分だけ再生の開始が遅れます。
+   * 複数を重ねて再生するとき、この遅れがずれになります。2 人分を続けて
+   * `playTalk()` すると、2 人目は 1 人目の生成が終わってから始まります。
+   * 先に両方を生成しておけば、ずれずに重なります。
+   *
+   * @param {string|string[]} name `defineTalk()` で登録した名前。配列で渡せます
+   * @returns {void}
+   */
+  prepareTalk(name) {
+    // 重ねる分をまとめて作る。1 つずつ呼ばせると、書き忘れた分だけずれる
+    if (Array.isArray(name)) { for (const n of name) this.prepareTalk(n); return; }
+    const def = this.talkDefs.get(name);
+    if (!def || !this.ctx || def.buffer) return;
+    // 粗さを保ったまま再生したいので、生成したサンプリング周波数のまま
+    // AudioBuffer を作る。再生時にブラウザが補間する
+    const { rate, data } = renderTalk(def.text, def.opts);
+    const buf = this.ctx.createBuffer(1, data.length, rate);
+    buf.getChannelData(0).set(data);
+    def.buffer = buf;
+  }
+
+  /**
+   * 登録済みのテキストを再生します。
+   *
+   * 波形は初回に生成し、名前ごとに保持します。2 回目以降は作り直しません。
+   * 同時再生数（`maxTalk`）を超えると、優先度の低いものが停止します。
+   *
+   * @param {string|string[]} name `defineTalk()` で登録した名前。
+   *   配列を渡すと、すべての波形を生成してから続けて再生します
+   * @param {number} [priority=0] 値が大きいほど優先されます
+   * @param {object} [opts]
+   *   `gain` は音量の倍率、`rate` は再生速度（1 より大きいと速く高くなります）
+   * @returns {number|number[]|undefined} 再生 ID。配列を渡したときは配列。
+   *   再生できなかったときは undefined
+   */
+  playTalk(name, priority = 0, opts = {}) {
+    // 再生の前に必ず有効にする。呼び出し側に unlock() を書かせると、
+    // 書き忘れが「音が鳴らない」という形で出てしまう
+    this.unlock();
+    // 重ねるときは配列で渡す。先にすべての波形を作ってから再生するので、
+    // 2 人目が 1 人目の生成を待たずに済む。
+    // 2 番目の引数は優先度なので、名前を並べる形にはできない
+    if (Array.isArray(name)) {
+      this.prepareTalk(name);
+      return name.map((n) => this.playTalk(n, priority, opts));
+    }
+    const def = this.talkDefs.get(name);
+    if (!def || !this.ctx) return;
+    // 同時に再生できるセリフの数を超えた分は、古いほうから止める
+    const room = Math.max(1, this.maxTalk | 0) || 1;
+    const talking = this.seVoices.filter((v) => v.talk);
+    for (let i = 0; i <= talking.length - room; i++) this._stopVoice(talking[i]);
+    const now = this.ctx.currentTime;
+    this._cleanupSE(now);
+    if (this.seVoices.some(v => v.exclusive && v.priority > priority)) return;
+    // 空きが無ければ、優先度の低いものを止めて作る
+    while (this._usedVoices() + 1 > this.maxVoices) {
+      let low = null;
+      for (const v of this.seVoices) {
+        if (v.priority >= priority) continue;
+        if (!low || v.priority < low.priority) low = v;
+      }
+      if (!low) return 0;
+      this._stopVoice(low);
+    }
+    this.prepareTalk(name);
+    const gain = this.ctx.createGain();
+    gain.gain.value = (def.opts.gain ?? 1) * 0.9;
+    gain.connect(this._out());
+    const src = this.ctx.createBufferSource();
+    src.buffer = def.buffer;
+    src.connect(gain);
+    const when = now + 0.02;
+    src.start(when);
+    const v = {
+      gain, nodes: [src], priority, voices: 1, noise: 0,
+      endTime: when + def.buffer.duration, exclusive: !!opts.exclusive,
+      talk: name, id: ++this._seSeq,
+    };
+    this.seVoices.push(v);
+    return v.id;
+  }
+
+  /**
+   * 保持している波形を破棄します。
+   *
+   * `defineTalk()` は名前ごとに波形を持ち続けます。作り直さずに済ませるためですが、
+   * その分メモリを使います。使わなくなったものは破棄できます。
+   *
+   * ```js
+   * voice.forgetTalk('hello');              // 名前を指定して破棄
+   * voice.forgetTalk(['demo1', 'demo2']);   // まとめて破棄
+   * voice.forgetTalk();                     // すべて破棄
+   * ```
+   *
+   * 再生中のものは最後まで再生されます。波形は再生側が参照しています。
+   *
+   * @param {string|string[]} [name] 登録名。省略するとすべて破棄します
+   * @returns {void}
+   */
+  forgetTalk(name) {
+    if (name == null) { this.talkDefs.clear(); return; }
+    for (const n of (Array.isArray(name) ? name : [name])) this.talkDefs.delete(n);
+  }
+
+  /**
+   * 再生中のものを停止します。
+   *
+   * @param {string|number} [what] 登録名、または `playTalk()` の戻り値。
+   *   省略するとすべて停止します
+   * @returns {void}
+   */
+  stopTalk(what) {
+    for (const v of [...this.seVoices]) {
+      if (!v.talk) continue;
+      if (what !== undefined && v.talk !== what && v.id !== what) continue;
+      this._stopVoice(v);
+    }
+  }
+}

package/src/version.js

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2026 harayoki
+// SPDX-License-Identifier: MIT
+
+/**
+ * RetroTalk のバージョン。`MmsxxRetroTalk.VERSION` として読めます。
+ *
+ * @type {string}
+ * @alias TalkAudio.VERSION
+ */
+export const RETROTALK_VERSION = '2.1.0';

package/src/voicevox.js

@@ -0,0 +1,245 @@
+// SPDX-FileCopyrightText: 2026 harayoki
+// SPDX-License-Identifier: MIT
+
+// VOICEVOX プロジェクトファイル（.vvproj）を解析して、RetroTalk で使えるデータを抜き出します。
+// /audio_query が返す JSON にも対応していますが未検証です。
+
+import { parseTalk } from './kana.js';
+
+/**
+ * 読み上げ指示パート（`query`）をソースデータから取り出します。
+ *
+ * `.vvproj` は文がいくつも入っているので、同じ並び順のまま返します。
+ * `/audio_query` の返り値は 1 つだけなので、そのまま 1 つ返します。
+ *
+ * @param {object} data 読み込んだ JSON
+ * @returns {Array<object>} query の並び
+ * @private
+ */
+function queries(data) {
+  const talk = data && data.talk;
+  if (talk && talk.audioItems) {
+    const keys = talk.audioKeys || Object.keys(talk.audioItems);
+    return keys.map((k) => talk.audioItems[k])
+      .filter((it) => it && it.query)
+      .map((it) => it.query);
+  }
+  if (data && (data.accentPhrases || data.accent_phrases)) return [data];
+  return [];
+}
+
+/**
+ * 拍 1 つの長さ(秒)。`consonantLength` と `vowelLength` を足す
+ * @private
+ */
+const moraSec = (mo) => (+mo.consonantLength || +mo.consonant_length || 0)
+  + (+mo.vowelLength || +mo.vowel_length || 0);
+
+/**
+ * 項目名の書き方が 2 通りある
+ * （`vowelLength` と `vowel_length`）
+ * @private
+ */
+const pick = (o, a, b, def) => {
+  const v = o[a] ?? o[b];
+  return v === undefined || v === null ? def : v;
+};
+
+// JSON から読む項目。
+//
+//   moras[].text          読み(カタカナ)
+//   moras[].vowel         大文字(A I U E O)なら無声化。N は撥音
+//   moras[].pitch         その拍の高さ。自然対数の Hz。0 は無声
+//   moras[].vowelLength   その拍の長さ(秒)。consonantLength と足して使う
+//   accent                アクセント核の位置
+//   pauseMora             句のあとの間
+//
+// パラメータは query に文ごとで入っている。
+//
+//   pitchScale        オクターブで数える(f0 × 2^pitchScale)ので、
+//                     対数で持っている pitch には pitchScale × ln2 を足す
+//   intonationScale   文まるごとの平均からの差を広げる / 狭める。
+//                     アクセント句ごとではない
+//   speedScale        速さ。長さを割る
+//   pauseLengthScale  間の長さを掛ける
+//
+// これ以外は 拍の並び 1つになる。
+
+/**
+ * 文ごとの設定を適用したうえで、拍を平らに並べます。
+ *
+ * @param {Array<object>} list `query` の並び
+ * @param {boolean} meta パラメータを掛けるか。外すと素の読みだけになる
+ * @returns {Array<object>} 拍と間の並び（`{ kana, pitch, sec }` か `{ gap }`）
+ * @private
+ */
+function flatten(list, meta) {
+  const out = [];
+  for (const q of list) {
+    const speedScale = meta ? (+pick(q, 'speedScale', 'speed_scale', 1) || 1) : 1;
+    const pitchScale = meta ? (+pick(q, 'pitchScale', 'pitch_scale', 0) || 0) : 0;
+    const intoScale = meta ? +pick(q, 'intonationScale', 'intonation_scale', 1) : 1;
+    const pauseScale = meta ? (+pick(q, 'pauseLengthScale', 'pause_length_scale', 1) || 1) : 1;
+    const pre = meta ? (+pick(q, 'prePhonemeLength', 'pre_phoneme_length', 0) || 0) : 0;
+    const post = meta ? (+pick(q, 'postPhonemeLength', 'post_phoneme_length', 0) || 0) : 0;
+    const phrases = q.accentPhrases || q.accent_phrases || [];
+    // 抑揚は、文まるごとの平均からの差を伸ばす。声の高さそのものは動かさない。
+    // 無声化した拍(高さを持たない)は、平均に入れない
+    const said = [];
+    for (const ph of phrases) {
+      for (const mo of ph.moras || []) if (+mo.pitch > 0) said.push(+mo.pitch);
+    }
+    const mid = said.length ? said.reduce((a, b) => a + b, 0) / said.length : 0;
+    const into = intoScale >= 0 ? intoScale : 1;
+    if (pre > 0) out.push({ gap: pre / speedScale });
+    for (const ph of phrases) {
+      const moras = ph.moras || [];
+      for (const mo of moras) {
+        const p = +mo.pitch || 0;
+        out.push({
+          kana: String(mo.text || ''),
+          // `pitchScale` はオクターブなので、対数へ直してから足す
+          pitch: p > 0 ? mid + (p - mid) * into + pitchScale * Math.LN2 : 0,
+          sec: moraSec(mo) / speedScale,
+        });
+      }
+      const pau = ph.pauseMora || ph.pause_mora;
+      if (pau) out.push({ gap: moraSec(pau) * pauseScale / speedScale });
+    }
+    if (post > 0) out.push({ gap: post / speedScale });
+    out.push({ end: true });                  // セリフの切れ目
+  }
+  return out;
+}
+
+/**
+ * VOICEVOX の会話情報を、RetroTalk 向けのテキストに変換します。
+ *
+ * VOICEVOX から抑揚と速度と音声を読み込めます。話者の情報は落としています。
+ * 拍ごとの高さと長さは `@p` と `@s` に、間は `、` と `。` に置き換えます。
+ *
+ * VOICEVOX の無声音の指定は無視します。（RetroTalk は自動で無声音の正誤とします）。
+ *
+ * @param {object|string} src `.vvproj` か `/audio_query` の返り
+ * @param {object} [opts]
+ *   `speed` は RetroTalk 側の速さ。長さはこれに合わせて置き直します（高さはそのまま）。
+ *   `usePitch` を外すと `@p` を、`useLength` を外すと `@s` を書きません。
+ *   `useMeta` を外すと VOICEVOX 側のパラメータ（話速・抑揚・間）を掛けません。
+ *   すべて外すと、読みと切れ目だけになります
+ * @returns {string} RetroTalk の文
+ * @alias TalkAudio.voicevoxText
+ * @static
+ */
+export function voicevoxText(src, opts = {}) {
+  let data = src;
+  if (typeof data === 'string') {
+    try { data = JSON.parse(data); } catch (e) { data = null; }
+  }
+  const list = queries(data);
+  if (!list.length) {
+    console.warn('[RetroTalk] VOICEVOX の読みが見つかりません'
+      + '(.vvproj の talk か、/audio_query の返しを渡してください)');
+    return '';
+  }
+  const usePitch = opts.usePitch !== false;
+  const useLength = opts.useLength !== false;
+  const flat = flatten(list, opts.useMeta !== false);
+
+  // 長さだけ、RetroTalk の速さに合わせて置き直す。
+  // VOICEVOX の秒数をそのまま使うと、RetroTalk の拍の長さと噛み合わない
+  const base0 = +opts.speed > 0 ? +opts.speed : 1;
+  const secs = flat.filter((f) => f.sec > 0).map((f) => f.sec);
+  const midSec = secs.length ? secs.reduce((a, b) => a + b, 0) / secs.length : 0;
+  /** 高さは、そのまま Hz にする(`pitch` は自然対数の Hz) */
+  const toHz = (p) => Math.max(50, Math.min(800, Math.round(Math.exp(p))));
+  /**
+   * 長さの値を変換する(%)。
+   *
+   * VOICEVOX の拍は 2 倍以上に伸び縮みするが、
+   * RetroTalk の拍はもともと子音のぶんだけで長さが違う。、
+   * そのまま扱うと速くなるところが速くなりすぎる。平方根で調整して 上と下も抑制する。
+   */
+  const toSpeed = (sec) => Math.round(100 * Math.max(0.6, Math.min(1.8,
+    base0 * Math.sqrt(midSec / sec))));
+
+  let out = '';
+  let speed = Math.round(base0 * 100);
+  let hz = 0;
+  for (const f of flat) {
+    if (f.end) { out += '。'; continue; }
+    if (f.gap !== undefined) {
+      // 間は、書ける長さに丸める。`、` が 0.12 秒、`。` が 0.24 秒。
+      // 秒より細かいところは移らない。
+      // 長さを引き継がないときは、切れ目だけを `、` で置く
+      if (!useLength) out += '、';
+      else if (f.gap >= 0.2) out += '。';
+      else if (f.gap >= 0.08) out += '、';
+      else out += ' ';
+      continue;
+    }
+    if (usePitch && f.pitch > 0 && toHz(f.pitch) !== hz) {
+      hz = toHz(f.pitch);
+      out += '@p' + hz;
+    }
+    if (useLength && midSec > 0 && f.sec > 0) {
+      const want = toSpeed(f.sec);
+      if (want !== speed) { speed = want; out += '@s' + speed; }
+    }
+    out += f.kana;
+  }
+  // 切れ目が重なったところは 1 つにする。長いほうを残す。
+  // セリフの終わりの 。 の直後に、次のセリフの頭の間が続くことがある
+  return out
+    .replace(/[、。 ]*。[、。 ]*/g, '。')
+    .replace(/[、 ]*、[、 ]*/g, '、')
+    .replace(/ +/g, ' ')
+    .replace(/^[、。 ]+/, '')
+    .trim();
+}
+
+/**
+ * データが正しく読めるかどうかを調べます。
+ *
+ * `voicevoxText()` は読み取れたものだけを返す。
+ * 読めなかったときは空の文字列が返る。
+ *
+ * @param {object|string} src `.vvproj` か `/audio_query` の返り
+ * @returns {{ok:boolean, version:string, lines:number, moras:number}}
+ *   `version` は VOICEVOX のバージョン、`lines` は文の数、`moras` は拍の数
+ * @alias TalkAudio.voicevoxInfo
+ * @static
+ */
+export function voicevoxInfo(src) {
+  let data = src;
+  if (typeof data === 'string') {
+    try { data = JSON.parse(data); } catch (e) { data = null; }
+  }
+  const list = queries(data);
+  let moras = 0;
+  for (const q of list) {
+    for (const ph of q.accentPhrases || q.accent_phrases || []) {
+      moras += (ph.moras || []).length;
+    }
+  }
+  return {
+    ok: list.length > 0 && moras > 0,
+    version: String((data && (data.appVersion || data.app_version)) || ''),
+    lines: list.length,
+    moras,
+  };
+}
+
+/**
+ * VOICEVOX の読みを、拍の並びに変換します。`parseTalk()` と同じ形で返します。
+ *
+ * いったん RetroTalk の文に変換してから読み直します。、
+ * 表示される文と実際になる音が必ず同じものになります。
+ *
+ * @param {object|string} src `.vvproj` か `/audio_query` の返り（文字列でもよい）
+ * @param {object} [opts] `voicevoxText()` と同じ
+ * @returns {Array} 拍の並び
+ * @private
+ */
+export function parseVoicevox(src, opts = {}) {
+  return parseTalk(voicevoxText(src, opts));
+}

package/src/wav.js

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2026 harayoki
+// SPDX-License-Identifier: MIT
+
+/**
+ * 音声データを WAV（RIFF / 16 ビット PCM）のバイト列に変換します。
+ *
+ * 外部に保存したいときに使います。
+ *
+ * `renderTalk()` が返すのは `{ rate, data }` なので、包み直してから渡します。
+ *
+ * ```js
+ * const got = MmsxxRetroTalk.renderTalk('コンニチワ');
+ * const wav = MmsxxRetroTalk.encodeWAV({
+ *   sampleRate: got.rate, numberOfChannels: 1, length: got.data.length,
+ *   getChannelData: () => got.data,
+ * });
+ * const url = URL.createObjectURL(new Blob([wav], { type: 'audio/wav' }));
+ * ```
+ *
+ * Web Audio を必要としないため、ブラウザの外でも実行できます。
+ *
+ * @param {{sampleRate: number, numberOfChannels: number, length: number,
+ *          getChannelData: function(number): Float32Array}} buffer
+ *   AudioBuffer、または同じ形のオブジェクト
+ * @returns {Uint8Array} 44 バイトのヘッダーと、それに続く音声データ
+ * @alias TalkAudio.encodeWAV
+ * @static
+ */
+export function encodeWAV(buffer) {
+  const ch = buffer.numberOfChannels;
+  const frames = buffer.length;
+  const rate = buffer.sampleRate;
+  const bytes = 2;                        // 16 ビット
+  const dataSize = frames * ch * bytes;
+  const out = new Uint8Array(44 + dataSize);
+  const view = new DataView(out.buffer);
+  let p = 0;
+  const str = (t) => { for (const c of t) out[p++] = c.charCodeAt(0); };
+  const u32 = (v) => { view.setUint32(p, v, true); p += 4; };
+  const u16 = (v) => { view.setUint16(p, v, true); p += 2; };
+
+  str('RIFF'); u32(36 + dataSize); str('WAVE');
+  str('fmt '); u32(16); u16(1); u16(ch);
+  u32(rate); u32(rate * ch * bytes); u16(ch * bytes); u16(8 * bytes);
+  str('data'); u32(dataSize);
+
+  const src = [];
+  for (let c = 0; c < ch; c++) src.push(buffer.getChannelData(c));
+  for (let i = 0; i < frames; i++) {
+    for (let c = 0; c < ch; c++) {
+      const v = Math.max(-1, Math.min(1, src[c][i]));
+      // 負の側だけ 32768 倍するのは、-1 をちょうど -32768 に合わせるため。
+      // 両側を 32767 倍すると、いちばん低いところがわずかに浅くなる
+      view.setInt16(p, Math.round(v < 0 ? v * 0x8000 : v * 0x7fff), true);
+      p += 2;
+    }
+  }
+  return out;
+}