@danything/arib 0.0.0-stage → 0.1.0

package/dist/b24caption.js

@@ -0,0 +1,987 @@
+/**
+ * 放送の字幕 (ARIB STD-B24 の字幕文) をデコードして、**字の置き場所まで決める** ([caption-text.ts](caption-text.ts))。
+ *
+ * libaribcaption の「デコードする (decoder)」側を写したもの — 置き場所・大きさ・色・外字の置き換えまでは
+ * 同じ計算で、描く (renderer) 手前で止める。描くのは受け側 (ブラウザ・アプリ)。
+ *
+ * 写したのは日本の放送で要るところだけ: 8単位符号 (JIS)・Profile A (フルセグ)。言語は1つを選んで読む
+ * (既定は第1言語。`new B24CaptionDecoder(2)` で第2言語)。
+ * ブラジルの Latin・UTF-8・ワンセグ (Profile C) は持たない。
+ *
+ * ## libaribcaption と違えたところ
+ *
+ * - **字幕管理データの「送り直し」の見分け。** あちらは群 (A/B) を `(id & 0xF0) >> 8` で
+ *   取っていて常に 0 になり、最初の1回しか読まない。ここは群を正しく見る
+ *   (番組が変わって群が替わったときに書式を読み直す)
+ * - **点滅 (FLC) を読み取る。** あちらは読み捨てている
+ *
+ * 入力は字幕の PES の中身 (データ識別 0x80 から)。ffmpeg が `-c:s copy` で Matroska
+ * (`S_ARIBSUB`) に入れたコマの中身がそのままこれになる。
+ */
+import { createHash } from "node:crypto";
+import { ADDITIONAL, ALNUM_FULL, ALNUM_HALF, CLUT, DRCS_REPLACE, HIRAGANA, JISX0201, JISX0201_HALF, KANA_SYMBOLS_HALF, KANJI_DIFF, KANJI_SYMBOLS_HALF, KATAKANA, } from "./b24-tables.js";
+import { ascii, u16, u24 } from "./bytes.js";
+import { CAPTION_TEXT_VERSION, captionLanguage, } from "./caption-text.js";
+import { smoothDrcs } from "./drcs-smooth.js";
+const KANJI = { set: "kanji", bytes: 2 };
+const ALNUM = { set: "alnum", bytes: 1 };
+const HIRA = { set: "hiragana", bytes: 1 };
+const KATA = { set: "katakana", bytes: 1 };
+const MACRO = { set: "macro", bytes: 1 };
+const MOSAIC = { set: "mosaic", bytes: 1 };
+/** 終端バイト → 集合 (G の指示)。プロポーショナルも JIS X 0213 も同じ表で引く (libaribcaption と同じ) */
+const G_SETS = new Map([
+    [0x42, KANJI],
+    [0x4a, ALNUM],
+    [0x30, HIRA],
+    [0x31, KATA],
+    [0x32, MOSAIC],
+    [0x33, MOSAIC],
+    [0x34, MOSAIC],
+    [0x35, MOSAIC],
+    [0x36, ALNUM],
+    [0x37, HIRA],
+    [0x38, KATA],
+    [0x49, { set: "jisx0201", bytes: 1 }],
+    [0x39, KANJI],
+    [0x3a, KANJI],
+    [0x3b, { set: "additional", bytes: 2 }],
+]);
+/** 終端バイト → DRCS の面 (0x40 は2バイトの面 0)。0x70 はマクロ */
+function drcsSet(final) {
+    if (final === 0x70)
+        return MACRO;
+    if (final < 0x40 || final > 0x4f)
+        return undefined;
+    const index = final - 0x40;
+    return { set: { drcs: index }, bytes: index === 0 ? 2 : 1 };
+}
+/** マクロの終わりはどれも同じ: G3 にマクロを載せて (ESC 0x2B 0x20 0x70)、LS0・LS2R */
+const MACRO_TAIL = [0x1b, 0x2b, 0x20, 0x70, 0x0f, 0x1b, 0x7d];
+/** 既定のマクロ (0x60〜0x6F)。符号の集合を組み替えるだけ。ここに書くのは G0〜G2 の指示 (ESC 列) */
+const MACROS = [
+    "1b2442 1b294a 1b2a30",
+    "1b2442 1b2931 1b2a30",
+    "1b2442 1b292041 1b2a30",
+    "1b2832 1b2934 1b2a35",
+    "1b2832 1b2933 1b2a35",
+    "1b2832 1b292041 1b2a35",
+    "1b282041 1b292042 1b2a2043",
+    "1b282044 1b292045 1b2a2046",
+    "1b282047 1b292048 1b2a2049",
+    "1b28204a 1b29204b 1b2a204c",
+    "1b28204d 1b29204e 1b2a204f",
+    "1b2442 1b292042 1b2a30",
+    "1b2442 1b292043 1b2a30",
+    "1b2442 1b292044 1b2a30",
+    "1b2831 1b2930 1b2a4a",
+    "1b284a 1b2932 1b2a2041",
+].map((head) => {
+    const bytes = [...head.matchAll(/[0-9a-f]{2}/g)].map(([b]) => Number.parseInt(b, 16));
+    return Uint8Array.from([...bytes, ...MACRO_TAIL]);
+});
+const eucjp = new TextDecoder("euc-jp");
+/** 漢字の表 (区×94+点 → 字)。EUC-JP で読み、libaribcaption と違うところだけ差し替える */
+const kanjiOverride = new Map();
+for (const [start, chars] of KANJI_DIFF) {
+    let i = start;
+    for (const char of chars)
+        kanjiOverride.set(i++, char.codePointAt(0));
+}
+const kanjiCache = new Map();
+function kanji(index) {
+    const known = kanjiOverride.get(index) ?? kanjiCache.get(index);
+    if (known !== undefined)
+        return known;
+    const text = eucjp.decode(Uint8Array.of(Math.floor(index / 94) + 0xa1, (index % 94) + 0xa1));
+    const code = text.codePointAt(0) ?? 0xfffd;
+    kanjiCache.set(index, code);
+    return code;
+}
+/** 表の文字列から i 番目のコードポイント (サロゲートを跨ぐので配列にしておく) */
+const points = (table) => [...table].map((c) => c.codePointAt(0));
+const T = {
+    hiragana: points(HIRAGANA),
+    katakana: points(KATAKANA),
+    kanaHalf: points(KANA_SYMBOLS_HALF),
+    jisx0201: points(JISX0201),
+    jisx0201Half: points(JISX0201_HALF),
+    alnumFull: points(ALNUM_FULL),
+    alnumHalf: points(ALNUM_HALF),
+    kanjiHalf: points(KANJI_SYMBOLS_HALF),
+    additional: points(ADDITIONAL),
+};
+/** 色。CLUT の組 (0〜7) と番号 (0〜15) */
+function clut(palette, index) {
+    return `#${CLUT[palette * 16 + index] ?? CLUT[index]}`;
+}
+/** 区画の幅か高さ。`floor((字の大きさ + 字間・行間) × 倍率)` */
+function section(size, spacing, scale) {
+    return Math.floor((size + spacing) * scale);
+}
+/** 半角の字 (libaribcaption の IsHalfwidthCharacter)。中くらいでも縮めずに描く */
+function isHalfwidth(code) {
+    return ((code !== 0 && code <= 0xff) ||
+        (code >= 0xff61 && code <= 0xff9f) ||
+        (code >= 0xffe8 && code <= 0xffee));
+}
+/**
+ * 送る画像 (なめらかにした濃淡。drcs-smooth.ts) を元の画像の MD5 ごとに覚えておく。放送は字幕文のたびに
+ * 同じ外字を定義し直してくるので、定義ごとではなくここで1回だけ作る
+ */
+const smoothed = new Map();
+const SMOOTHED_MAX = 256;
+function sendable(drcs) {
+    // MD5 は画素だけから取っているので、大きさも鍵に入れる
+    const key = `${drcs.md5}:${drcs.width}x${drcs.height}:${drcs.depth}`;
+    let sent = smoothed.get(key);
+    if (sent === undefined) {
+        sent = {
+            ...smoothDrcs(drcs.width, drcs.height, drcs.depth, drcs.bits, drcs.pixels),
+            md5: drcs.md5,
+        };
+        if (smoothed.size >= SMOOTHED_MAX)
+            smoothed.clear();
+        smoothed.set(key, sent);
+    }
+    return sent;
+}
+/**
+ * 字幕のストリーム1本ぶんのデコーダ。**状態を持つ** (書式・位置・色・外字は字幕文を跨いで続く) ので、
+ * ストリームごとに1つ作って、届いた順に食わせる。
+ *
+ * **読むのは1つの言語だけ** (`language`。1〜8)。言語ごとに書式も位置も別に続くので、2つの言語を出し分けるなら
+ * 言語ごとに1つ作って、同じコマを両方に食わせる (`server/captions.ts` の `CaptionText`)
+ */
+export class B24CaptionDecoder {
+    language;
+    /** 字幕管理データに書いてある言語。まだ届いていなければ空 */
+    languages = [];
+    gx = [KANJI, ALNUM, HIRA, MACRO];
+    gl = 0;
+    gr = 2;
+    drcsMaps = Array.from({ length: 16 }, () => new Map());
+    prevGroup = -1;
+    swf = 7;
+    planeWidth = 960;
+    planeHeight = 540;
+    areaWidth = 960;
+    areaHeight = 540;
+    areaX = 0;
+    areaY = 0;
+    posInited = false;
+    posX = 0;
+    posY = 0;
+    charWidth = 36;
+    charHeight = 36;
+    hSpacing = 4;
+    vSpacing = 24;
+    hScale = 1;
+    vScale = 1;
+    underline = false;
+    bold = false;
+    italic = false;
+    stroke = null;
+    box = 0;
+    flash = false;
+    palette = 0;
+    fg = clut(0, 7);
+    bg = clut(0, 8);
+    caption = {
+        chars: [],
+        clear: false,
+        wait: null,
+        drcs: new Map(),
+    };
+    /** @param language 読む言語 (1〜8。データグループの番号) */
+    constructor(language = 1) {
+        this.language = language;
+        this.resetState();
+    }
+    /**
+     * 字幕の PES の中身を1つ食わせる。
+     *
+     * @returns 出す1枚。出すものが無ければ (字幕管理データ・送り直し・待ちだけの字幕文) null
+     */
+    decode(data) {
+        const begin = groupAt(data);
+        if (begin < 0 || begin + 5 > data.length)
+            return null;
+        const groupId = data[begin] >> 2;
+        const size = u16(data, begin + 3);
+        if (size === 0 || begin + 5 + size > data.length)
+            return null;
+        const body = data.subarray(begin + 5, begin + 5 + size);
+        this.caption = { chars: [], clear: false, wait: null, drcs: new Map() };
+        const id = groupId & 0x0f;
+        const group = groupId >> 4;
+        if (id === 0) {
+            // 字幕管理データ。**同じ群は送り直し** (ARIB TR-B14 4.2.4)
+            if (group === this.prevGroup)
+                return null;
+            this.prevGroup = group;
+            this.management(body);
+        }
+        else {
+            // 選んだ言語の字幕文だけ
+            if (id !== this.language)
+                return null;
+            this.statement(body);
+        }
+        return toPage(this.caption, [this.planeWidth, this.planeHeight]);
+    }
+    resetGraphicSets() {
+        this.gx = [KANJI, ALNUM, HIRA, MACRO];
+        this.gl = 0;
+        this.gr = 2;
+    }
+    /** 書式 (SWF) に合わせた面と字の大きさ。Profile A の表 */
+    resetWritingFormat() {
+        const [w, h, hs, vs] = this.swf === 5
+            ? [1920, 1080, 4, 24]
+            : this.swf === 8
+                ? [960, 540, 12, 24]
+                : this.swf === 9
+                    ? [720, 480, 4, 16]
+                    : this.swf === 10
+                        ? [720, 480, 8, 24]
+                        : [960, 540, 4, 24];
+        this.planeWidth = this.areaWidth = w;
+        this.planeHeight = this.areaHeight = h;
+        this.charWidth = 36;
+        this.charHeight = 36;
+        this.hSpacing = hs;
+        this.vSpacing = vs;
+    }
+    resetState() {
+        this.resetGraphicSets();
+        this.resetWritingFormat();
+        this.areaX = 0;
+        this.areaY = 0;
+        this.posInited = false;
+        this.posX = 0;
+        this.posY = 0;
+        this.hScale = 1;
+        this.vScale = 1;
+        this.underline = false;
+        this.bold = false;
+        this.italic = false;
+        this.stroke = null;
+        this.box = 0;
+        this.flash = false;
+        this.palette = 0;
+        this.fg = clut(0, 7);
+        this.bg = clut(0, 8);
+    }
+    management(data) {
+        if (data.length < 10)
+            return;
+        let at = 1;
+        if (data[0] >> 6 === 0b10)
+            at += 5; // OTM
+        const languages = data[at++];
+        if (languages === 0 || languages > 8)
+            return;
+        const found = [];
+        for (let i = 0; i < languages; i++) {
+            if (at + 6 > data.length)
+                return;
+            const tag = data[at] >> 5;
+            const dmf = data[at] & 0x0f;
+            at += 1;
+            if (dmf === 0b1100 || dmf === 0b1101 || dmf === 0b1110)
+                at += 1;
+            const code = ascii(data, at, 3);
+            at += 3; // ISO 639
+            const format = data[at] >> 4;
+            at += 1;
+            found.push(captionLanguage(tag + 1, /^[a-z]{3}$/.test(code) ? code : ""));
+            // 書式は選んだ言語のものを使う
+            if (tag === this.language - 1) {
+                this.swf = format - 1;
+                this.resetGraphicSets();
+                this.resetWritingFormat();
+            }
+        }
+        this.languages = found;
+        if (at + 3 > data.length)
+            return;
+        const length = u24(data, at);
+        at += 3;
+        if (length > 0 && at + length <= data.length)
+            this.dataUnits(data.subarray(at, at + length));
+    }
+    statement(data) {
+        if (data.length < 4)
+            return;
+        let at = 1;
+        const tmd = data[0] >> 6;
+        if (tmd === 0b01 || tmd === 0b10)
+            at += 5; // STM
+        if (at + 4 > data.length)
+            return;
+        const length = u24(data, at);
+        at += 3;
+        if (length > 0 && at + length <= data.length)
+            this.dataUnits(data.subarray(at, at + length));
+    }
+    dataUnits(data) {
+        let at = 0;
+        while (at + 5 <= data.length) {
+            if (data[at] !== 0x1f)
+                return;
+            const parameter = data[at + 1];
+            const size = u24(data, at + 2);
+            if (size === 0 || at + 5 + size > data.length)
+                return;
+            const unit = data.subarray(at + 5, at + 5 + size);
+            if (parameter === 0x20)
+                this.body(unit);
+            else if (parameter === 0x30)
+                this.defineDrcs(unit, 1);
+            else if (parameter === 0x31)
+                this.defineDrcs(unit, 2);
+            at += 5 + size;
+        }
+    }
+    /** 本文。**読めないところで止める** (そこまでの字は出す。libaribcaption と同じ) */
+    body(data) {
+        let at = 0;
+        while (at < data.length) {
+            const byte = data[at];
+            const used = byte <= 0x20
+                ? this.c0(data, at)
+                : byte < 0x7f
+                    ? this.graphic(data, at, this.gx[this.gl])
+                    : byte <= 0xa0
+                        ? this.c1(data, at)
+                        : byte < 0xff
+                            ? this.graphic(data, at, this.gx[this.gr])
+                            : 0;
+            if (used <= 0)
+                return;
+            at += used;
+        }
+    }
+    defineDrcs(data, byteCount) {
+        if (data.length === 0)
+            return;
+        let at = 1;
+        const codes = data[0];
+        for (let i = 0; i < codes; i++) {
+            if (at + 3 > data.length)
+                return;
+            const code = u16(data, at);
+            const fonts = data[at + 2];
+            at += 3;
+            for (let j = 0; j < fonts; j++) {
+                if (at + 4 > data.length)
+                    return;
+                const mode = data[at] & 0x0f;
+                at += 1;
+                if (mode === 0b0000 || mode === 0b0001) {
+                    const depth = data[at] + 2;
+                    const width = data[at + 1];
+                    const height = data[at + 2];
+                    at += 3;
+                    let bits = 0;
+                    for (let n = depth - 1; n > 0; n >>= 1)
+                        bits++;
+                    const size = Math.ceil((width * height * bits) / 8);
+                    if (at + size > data.length)
+                        return;
+                    const pixels = data.slice(at, at + size);
+                    at += size;
+                    const md5 = createHash("md5").update(pixels).digest("hex");
+                    const drcs = {
+                        width,
+                        height,
+                        depth,
+                        bits,
+                        pixels,
+                        replaced: DRCS_REPLACE.get(md5) ?? null,
+                        md5,
+                    };
+                    if (byteCount === 1) {
+                        const set = drcsSet(((code & 0x0f00) >> 8) + 0x40);
+                        if (set !== undefined && typeof set.set === "object") {
+                            this.drcsMaps[set.set.drcs].set(code & 0x7f, drcs);
+                        }
+                    }
+                    else {
+                        const key = code >= 0xec00 && code <= 0xf8ff ? code : code & 0x7f7f;
+                        this.drcsMaps[0].set(key, drcs);
+                    }
+                }
+                else {
+                    // 幾何図形。読み飛ばす
+                    if (at + 4 > data.length)
+                        return;
+                    at += 4 + u16(data, at + 2);
+                }
+            }
+        }
+    }
+    /** @returns 使ったバイト数。0 なら読めない */
+    c0(data, at) {
+        const rest = data.length - at;
+        switch (data[at]) {
+            case 0x08: // APB
+                this.moveRelative(-1, 0);
+                return 1;
+            case 0x09: // APF
+                this.moveRelative(1, 0);
+                return 1;
+            case 0x0a: // APD
+                this.moveRelative(0, 1);
+                return 1;
+            case 0x0b: // APU
+                this.moveRelative(0, -1);
+                return 1;
+            case 0x0c: // CS
+                this.resetState();
+                this.caption.clear = true;
+                return 1;
+            case 0x0d: // APR
+                this.newline();
+                return 1;
+            case 0x0e: // LS1
+                this.gl = 1;
+                return 1;
+            case 0x0f: // LS0
+                this.gl = 0;
+                return 1;
+            case 0x16: // PAPF
+                if (rest < 2)
+                    return 0;
+                this.moveRelative(data[at + 1] & 0x3f, 0);
+                return 2;
+            case 0x19: // SS2
+            case 0x1d: {
+                // SS3
+                if (rest < 2)
+                    return 0;
+                const used = this.graphic(data, at + 1, this.gx[data[at] === 0x19 ? 2 : 3]);
+                return used <= 0 ? 0 : 1 + used;
+            }
+            case 0x1b: {
+                if (rest < 2)
+                    return 0;
+                const used = this.escape(data, at + 1);
+                return used < 0 ? 0 : 1 + used;
+            }
+            case 0x1c: // APS
+                if (rest < 3)
+                    return 0;
+                this.setAbsolute(data[at + 2] & 0x3f, data[at + 1] & 0x3f);
+                return 3;
+            case 0x20: // SP
+                this.push(this.msz() ? 0x20 : 0x3000);
+                this.moveRelative(1, 0);
+                return 1;
+            default:
+                return 1;
+        }
+    }
+    escape(data, at) {
+        const rest = data.length - at;
+        const byte = data[at];
+        switch (byte) {
+            case 0x6e: // LS2
+                this.gl = 2;
+                return 1;
+            case 0x6f: // LS3
+                this.gl = 3;
+                return 1;
+            case 0x7e: // LS1R
+                this.gr = 1;
+                return 1;
+            case 0x7d: // LS2R
+                this.gr = 2;
+                return 1;
+            case 0x7c: // LS3R
+                this.gr = 3;
+                return 1;
+        }
+        if (byte === 0x24) {
+            if (rest < 2)
+                return -1;
+            const next = data[at + 1];
+            if (next >= 0x28 && next <= 0x2b) {
+                if (rest < 3)
+                    return -1;
+                if (data[at + 2] === 0x20) {
+                    if (rest < 4)
+                        return -1;
+                    const set = drcsSet(data[at + 3]);
+                    if (set !== undefined)
+                        this.gx[next - 0x28] = set;
+                    return 4;
+                }
+                const set = G_SETS.get(data[at + 2]);
+                if (set !== undefined)
+                    this.gx[next - 0x28] = set;
+                return 3;
+            }
+            const set = G_SETS.get(next);
+            if (set !== undefined)
+                this.gx[0] = set;
+            return 2;
+        }
+        if (byte >= 0x28 && byte <= 0x2b) {
+            if (rest < 2)
+                return -1;
+            if (data[at + 1] === 0x20) {
+                if (rest < 3)
+                    return -1;
+                const set = drcsSet(data[at + 2]);
+                if (set !== undefined)
+                    this.gx[byte - 0x28] = set;
+                return 3;
+            }
+            const set = G_SETS.get(data[at + 1]);
+            if (set !== undefined)
+                this.gx[byte - 0x28] = set;
+            return 2;
+        }
+        // 知らない ESC は、ESC 1バイトだけ読んだことにする (libaribcaption と同じ)
+        return 0;
+    }
+    c1(data, at) {
+        const rest = data.length - at;
+        const byte = data[at];
+        if (byte >= 0x80 && byte <= 0x87) {
+            // BKF〜WHF
+            this.fg = clut(this.palette, byte - 0x80);
+            return 1;
+        }
+        switch (byte) {
+            case 0x90: {
+                // COL
+                if (rest < 2)
+                    return 0;
+                const p = data[at + 1];
+                if (p === 0x20) {
+                    if (rest < 3)
+                        return 0;
+                    this.palette = data[at + 2] & 0x07;
+                    return 3;
+                }
+                if (p >= 0x48 && p <= 0x7f) {
+                    if ((p & 0xf0) === 0x40)
+                        this.fg = clut(this.palette, p & 0x0f);
+                    else if ((p & 0xf0) === 0x50)
+                        this.bg = clut(this.palette, p & 0x0f);
+                    return 2;
+                }
+                return 0;
+            }
+            case 0x93: // POL
+            case 0x94: // WMM
+                return 2;
+            case 0x88: // SSZ
+                this.hScale = 0.5;
+                this.vScale = 0.5;
+                return 1;
+            case 0x89: // MSZ
+                this.hScale = 0.5;
+                this.vScale = 1;
+                return 1;
+            case 0x8a: // NSZ
+                this.hScale = 1;
+                this.vScale = 1;
+                return 1;
+            case 0x8b: // SZX
+                if (rest < 2)
+                    return 0;
+                if (data[at + 1] === 0x41)
+                    this.vScale = 2;
+                else if (data[at + 1] === 0x44)
+                    this.hScale = 2;
+                else if (data[at + 1] === 0x45) {
+                    this.hScale = 2;
+                    this.vScale = 2;
+                }
+                return 2;
+            case 0x91: // FLC。0x40 正相・0x47 逆相で点滅、0x4F で止める
+                if (rest < 2)
+                    return 0;
+                this.flash = data[at + 1] === 0x40 || data[at + 1] === 0x47;
+                return 2;
+            case 0x92: // CDC
+                if (rest < 2)
+                    return 0;
+                if (data[at + 1] === 0x20)
+                    return rest < 3 ? 0 : 3;
+                return 2;
+            case 0x9d: // TIME
+                if (rest < 3)
+                    return 0;
+                if (data[at + 1] === 0x20) {
+                    this.caption.wait =
+                        (this.caption.wait ?? 0) + (data[at + 2] & 0x3f) * 100;
+                    return 3;
+                }
+                return data[at + 1] === 0x28 ? 3 : 0;
+            case 0x95: // MACRO (TR-B14 で使わない)
+                return 0;
+            case 0x98: // RPC (libaribcaption も繰り返さない)
+                return rest < 2 ? 0 : 2;
+            case 0x9a: // STL
+                this.underline = true;
+                return 1;
+            case 0x99: // SPL
+                this.underline = false;
+                return 1;
+            case 0x97: // HLC
+                if (rest < 2)
+                    return 0;
+                this.box = data[at + 1] & 0x0f;
+                return 2;
+            case 0x9b: {
+                const used = this.csi(data, at + 1);
+                return used <= 0 ? 0 : 1 + used;
+            }
+            default:
+                return 1;
+        }
+    }
+    csi(data, at) {
+        const rest = data.length - at;
+        let offset = 0;
+        let p1 = 0;
+        let p2 = 0;
+        let count = 0;
+        while (offset < rest) {
+            const byte = data[at + offset];
+            if (byte >= 0x30 && byte <= 0x39) {
+                if (count <= 1)
+                    p2 = p2 * 10 + (byte & 0x0f);
+            }
+            else if (byte === 0x20) {
+                if (count === 0)
+                    p1 = p2;
+                count++;
+                break;
+            }
+            else if (byte === 0x3b) {
+                if (count === 0) {
+                    p1 = p2;
+                    p2 = 0;
+                }
+                count++;
+            }
+            offset++;
+        }
+        if (++offset >= rest)
+            return 0;
+        switch (data[at + offset]) {
+            case 0x53: // SWF
+                if (count === 1)
+                    this.swf = p1;
+                this.resetWritingFormat();
+                break;
+            case 0x56: // SDF
+                this.areaWidth = p1;
+                this.areaHeight = p2;
+                break;
+            case 0x57: // SSM
+                this.charWidth = p1;
+                this.charHeight = p2;
+                break;
+            case 0x58: // SHS
+                this.hSpacing = p1;
+                break;
+            case 0x59: // SVS
+                this.vSpacing = p1;
+                break;
+            case 0x5f: // SDP
+                this.areaX = p1;
+                if (count >= 2)
+                    this.areaY = p2;
+                if (!this.posInited)
+                    this.setAbsolute(0, 0);
+                break;
+            case 0x61: // ACPS
+                this.posInited = true;
+                this.posX = p1;
+                this.posY = p2;
+                break;
+            case 0x63: // ORN
+                if (p1 === 0)
+                    this.stroke = null;
+                else if (p1 === 1 && count >= 2) {
+                    const palette = Math.floor(p2 / 100);
+                    const index = p2 % 100;
+                    if (palette >= 8 || index >= 16)
+                        return 0;
+                    this.stroke = clut(palette, index);
+                }
+                break;
+            case 0x64: // MDF
+                if (p1 === 0) {
+                    this.bold = false;
+                    this.italic = false;
+                }
+                else if (p1 === 1)
+                    this.bold = true;
+                else if (p1 === 2)
+                    this.italic = true;
+                else if (p1 === 3) {
+                    this.bold = true;
+                    this.italic = true;
+                }
+                break;
+        }
+        return offset + 1;
+    }
+    /** 中くらい (MSZ) か。半角へ寄せる見分けに使う */
+    msz() {
+        return this.hScale * 2 === this.vScale;
+    }
+    graphic(data, at, entry) {
+        const ch = data[at] & 0x7f;
+        if (ch < 0x21 || ch >= 0x7f)
+            return 0;
+        let ch2 = 0;
+        if (entry.bytes === 2) {
+            if (at + 1 >= data.length)
+                return 0;
+            ch2 = data[at + 1] & 0x7f;
+            if (ch2 < 0x21 || ch2 >= 0x7f)
+                return 0;
+        }
+        const set = entry.set;
+        const index = ch - 0x21;
+        if (set === "hiragana" || set === "katakana") {
+            let code = (set === "hiragana" ? T.hiragana : T.katakana)[index];
+            if (ch >= 0x79 && this.msz())
+                code = T.kanaHalf[ch - 0x79];
+            this.push(code);
+            this.moveRelative(1, 0);
+        }
+        else if (set === "jisx0201") {
+            this.push((this.msz() ? T.jisx0201Half : T.jisx0201)[index]);
+            this.moveRelative(1, 0);
+        }
+        else if (set === "kanji" || set === "additional") {
+            const ku = ch - 0x21;
+            const ten = ch2 - 0x21;
+            let code;
+            if (ku < 84) {
+                const i = ku * 94 + ten;
+                code = kanji(i);
+                if (this.msz()) {
+                    if (ku < 2)
+                        code = T.kanjiHalf[i];
+                    if (code === 0x3000 || (code >= 0xff01 && code <= 0xff5e))
+                        code = (code & 0xff) + 0x20;
+                }
+            }
+            else {
+                code = T.additional[(ku - 84) * 94 + ten] ?? 0xfffd;
+            }
+            this.push(code);
+            this.moveRelative(1, 0);
+        }
+        else if (set === "alnum") {
+            this.push((this.msz() ? T.alnumHalf : T.alnumFull)[index]);
+            this.moveRelative(1, 0);
+        }
+        else if (set === "macro") {
+            if (ch >= 0x60 && ch <= 0x6f)
+                this.body(MACROS[ch & 0x0f]);
+        }
+        else if (typeof set === "object") {
+            const key = entry.bytes === 2 ? (ch << 8) | ch2 : ch;
+            const drcs = this.drcsMaps[set.drcs].get(key);
+            if (drcs === undefined) {
+                // 定義されていない外字は、ゲタ (〓) で埋める
+                this.push(0x3013);
+            }
+            else {
+                const code = (set.drcs << 16) | key;
+                this.caption.drcs.set(code, drcs);
+                if (drcs.replaced !== null)
+                    this.push(drcs.replaced);
+                else
+                    this.push(0x3013, code);
+            }
+            this.moveRelative(1, 0);
+        }
+        // モザイクは描かない (libaribcaption と同じ)
+        return entry.bytes;
+    }
+    push(code, drcs = null) {
+        this.caption.chars.push({
+            code,
+            drcs,
+            x: this.posX,
+            y: this.posY - this.sectionHeight(),
+            charWidth: this.charWidth,
+            charHeight: this.charHeight,
+            hSpacing: this.hSpacing,
+            vSpacing: this.vSpacing,
+            hScale: this.hScale,
+            vScale: this.vScale,
+            fg: this.fg,
+            bg: this.bg,
+            stroke: this.stroke,
+            underline: this.underline,
+            bold: this.bold,
+            italic: this.italic,
+            box: this.box,
+            flash: this.flash,
+            ruby: (this.hScale === 0.5 && this.vScale === 0.5) ||
+                (this.charWidth === 18 && this.charHeight === 18),
+        });
+    }
+    sectionWidth() {
+        return section(this.charWidth, this.hSpacing, this.hScale);
+    }
+    sectionHeight() {
+        return section(this.charHeight, this.vSpacing, this.vScale);
+    }
+    setAbsolute(x, y) {
+        this.posInited = true;
+        this.posX = this.areaX + x * this.sectionWidth();
+        this.posY = this.areaY + (y + 1) * this.sectionHeight();
+    }
+    moveRelative(x, y) {
+        if (this.posX < 0 || this.posY < 0)
+            this.setAbsolute(0, 0);
+        this.posInited = true;
+        while (x < 0) {
+            this.posX -= this.sectionWidth();
+            x++;
+            if (this.posX < this.areaX) {
+                this.posX = this.areaX + this.areaWidth - this.sectionWidth();
+                y--;
+            }
+        }
+        while (x > 0) {
+            this.posX += this.sectionWidth();
+            x--;
+            if (this.posX >= this.areaX + this.areaWidth) {
+                this.posX = this.areaX;
+                y++;
+            }
+        }
+        while (y < 0) {
+            this.posY -= this.sectionHeight();
+            y++;
+            if (this.posY < this.areaY)
+                this.posY = this.areaY + this.areaHeight;
+        }
+        while (y > 0) {
+            this.posY += this.sectionHeight();
+            y--;
+            if (this.posY > this.areaY + this.areaHeight)
+                this.posY = this.areaY + this.sectionHeight();
+        }
+    }
+    newline() {
+        if (this.posX < 0 || this.posY < 0)
+            this.setAbsolute(0, 0);
+        this.posInited = true;
+        this.posX = this.areaX;
+        this.posY += this.sectionHeight();
+    }
+}
+/**
+ * デコードした1枚を、送る形式にする。**同じ見た目で続いている字を1つの並びに束ねる。**
+ *
+ * libaribcaption の描き手 (region_renderer) が字ごとに計算している置き場所を、ここで
+ * 面の単位のまま済ませておく。区画は `floor((字の幅 + 字間) × 倍率)`、字の枠は区画の中で
+ * 字間の半分だけ右下へずらしたところ。
+ *
+ * @returns 出すものが無い (待ちだけの字幕文) なら null。CS だけなら「消す」1枚
+ */
+function toPage(caption, plane) {
+    if (caption.chars.length === 0 && !caption.clear)
+        return null;
+    const runs = [];
+    const drcs = {};
+    let last = null;
+    for (const char of caption.chars) {
+        const w = section(char.charWidth, char.hSpacing, char.hScale);
+        const h = section(char.charHeight, char.vSpacing, char.vScale);
+        const size = char.charHeight * char.vScale;
+        const glyphWidth = char.charWidth * char.hScale;
+        // 中くらいの半角の字は縮めない (もともと半分の幅。libaribcaption の DrawChar と同じ)
+        const halfAsked = Math.abs(glyphWidth / size - 0.5) < 0.05;
+        const scaleX = halfAsked && isHalfwidth(char.code) ? 1 : glyphWidth / size;
+        const run = {
+            x: char.x,
+            y: char.y,
+            w,
+            h,
+            fx: (char.hSpacing * char.hScale) / 2,
+            fy: (char.vSpacing * char.vScale) / 2,
+            size,
+            scaleX,
+            text: String.fromCodePoint(char.code),
+            fg: char.fg,
+            bg: char.bg,
+        };
+        if (char.drcs !== null) {
+            const key = String(char.drcs);
+            run.drcs = key;
+            const found = caption.drcs.get(char.drcs);
+            if (found !== undefined && drcs[key] === undefined) {
+                drcs[key] = sendable(found);
+            }
+        }
+        if (char.stroke !== null)
+            run.stroke = char.stroke;
+        if (char.underline)
+            run.underline = true;
+        if (char.bold)
+            run.bold = true;
+        if (char.italic)
+            run.italic = true;
+        if (char.box !== 0)
+            run.box = char.box;
+        if (char.flash)
+            run.flash = true;
+        if (char.ruby)
+            run.ruby = true;
+        // 見た目が同じで、すぐ右に続いていれば束ねる。外字の画像は1字ずつ
+        const { x: _x, y: _y, text: _t, ...looks } = run;
+        const key = JSON.stringify(looks);
+        if (last !== null &&
+            run.drcs === undefined &&
+            last.key === key &&
+            last.run.y === run.y &&
+            last.run.x + last.count * last.run.w === run.x) {
+            last.run.text += run.text;
+            last.count++;
+            continue;
+        }
+        runs.push(run);
+        last = { run, count: 1, key };
+    }
+    const page = {
+        v: CAPTION_TEXT_VERSION,
+        plane,
+        duration: caption.wait,
+        runs,
+    };
+    if (Object.keys(drcs).length > 0)
+        page.drcs = drcs;
+    return page;
+}
+/**
+ * 字幕の PES の中身で、データグループの頭の位置。データ識別 (0x80 = 字幕) と私的ストリーム識別 (0xFF) が
+ * 合わなければ -1
+ */
+function groupAt(data) {
+    if (data.length < 3 || data[0] !== 0x80 || data[1] !== 0xff)
+        return -1;
+    return 3 + (data[2] & 0x0f);
+}
+/** 字幕の PES の中身が字幕管理データか (データグループの番号が 0)。読めないものは false */
+export function isManagement(data) {
+    const begin = groupAt(data);
+    return (begin >= 0 && begin < data.length && ((data[begin] >> 2) & 0x0f) === 0);
+}