@danything/arib 2.0.0 → 2.2.0

package/dist/tlv.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TLV パケット (ARIB STD-B32 第 3 部) を切り出す。4K の放送 (MMT/TLV) の土台で、TS の `PacketStream` と同じ役。
+ *
+ * TLV パケットは `0x7F`・種類 (1 バイト)・長さ (2 バイト) のヘッダーと、長さぶんの中身でできている。
+ * 長さが毎回違うので、TS のように決まった間隔で同期のバイトを探すことはできない。
+ * エージェントはケーブルの分割 TLV を組み立て直した TLV のバイト列を流す
+ * ([agent.md](https://github.com/danything/denpa/blob/main/docs/agent.md))。
+ */
+export declare const TLV_IPV4 = 1;
+export declare const TLV_IPV6 = 2;
+/** ヘッダー圧縮した IP (`tlv-ip.ts`) */
+export declare const TLV_COMPRESSED_IP = 3;
+/** 伝送制御信号 (TLV-SI。TLV-NIT・AMT のセクションが並ぶ) */
+export declare const TLV_SIGNALING = 254;
+export declare const TLV_NULL = 255;
+export interface TlvPacket {
+    type: number;
+    /** ヘッダーを除いた中身 */
+    payload: Uint8Array;
+    /** ヘッダーを含めたパケット全体。1 局に絞るとき (`mmt-service-filter.ts`) はこれをそのまま出す */
+    bytes: Uint8Array;
+}
+/**
+ * 任意の長さで届く TLV のバイト列を TLV パケットに切り分ける。
+ *
+ * **先頭がパケットの先頭とは限らない。** 共有に途中から入った利用者は、TLV パケットの途中から受け取る
+ * ([agent.md](https://github.com/danything/denpa/blob/main/docs/agent.md))。そこで、同期が取れていないときは
+ * 先頭のバイトと種類が合い、**長さの先にある次のパケットの先頭も合う**位置を探して合わせる。
+ * 1 か所だけで決めると、中身にたまたまある `7F 03` を先頭と取り違える。そのため、同期を取る最初のパケットは次のパケットの先頭が届くまで出さない。
+ * 同期が取れたあとは、先頭が合わなくなるまでヘッダーの長さのとおりに進む。
+ *
+ * 出すパケットの中身は、渡されたチャンクか前の残りの一部を指す (コピーしない)。
+ * **次の `feed` より後まで持つならコピーすること** (`PacketStream` と同じ)
+ */
+export declare class TlvStream {
+    private rest;
+    private synced;
+    /** 合わせるために読み飛ばしたバイトの合計 */
+    skipped: number;
+    /** 同期を失って合わせ直した回数 */
+    resyncs: number;
+    feed(chunk: Uint8Array): Generator<TlvPacket>;
+}

package/dist/tlv.js

@@ -0,0 +1,119 @@
+/**
+ * TLV パケット (ARIB STD-B32 第 3 部) を切り出す。4K の放送 (MMT/TLV) の土台で、TS の `PacketStream` と同じ役。
+ *
+ * TLV パケットは `0x7F`・種類 (1 バイト)・長さ (2 バイト) のヘッダーと、長さぶんの中身でできている。
+ * 長さが毎回違うので、TS のように決まった間隔で同期のバイトを探すことはできない。
+ * エージェントはケーブルの分割 TLV を組み立て直した TLV のバイト列を流す
+ * ([agent.md](https://github.com/danything/denpa/blob/main/docs/agent.md))。
+ */
+import { concatBytes, u16 } from "./bytes.js";
+/** TLV パケットの先頭のバイト (上位 2 ビットが 01、残りは予約で 1) */
+const TLV_SYNC = 0x7f;
+const HEADER = 4;
+export const TLV_IPV4 = 0x01;
+export const TLV_IPV6 = 0x02;
+/** ヘッダー圧縮した IP (`tlv-ip.ts`) */
+export const TLV_COMPRESSED_IP = 0x03;
+/** 伝送制御信号 (TLV-SI。TLV-NIT・AMT のセクションが並ぶ) */
+export const TLV_SIGNALING = 0xfe;
+export const TLV_NULL = 0xff;
+const TYPES = new Set([
+    TLV_IPV4,
+    TLV_IPV6,
+    TLV_COMPRESSED_IP,
+    TLV_SIGNALING,
+    TLV_NULL,
+]);
+/** `at` が TLV パケットの先頭に見えるか (先頭のバイトと種類) */
+function looksLikeHead(data, at) {
+    return data[at] === TLV_SYNC && TYPES.has(data[at + 1]);
+}
+/**
+ * 任意の長さで届く TLV のバイト列を TLV パケットに切り分ける。
+ *
+ * **先頭がパケットの先頭とは限らない。** 共有に途中から入った利用者は、TLV パケットの途中から受け取る
+ * ([agent.md](https://github.com/danything/denpa/blob/main/docs/agent.md))。そこで、同期が取れていないときは
+ * 先頭のバイトと種類が合い、**長さの先にある次のパケットの先頭も合う**位置を探して合わせる。
+ * 1 か所だけで決めると、中身にたまたまある `7F 03` を先頭と取り違える。そのため、同期を取る最初のパケットは次のパケットの先頭が届くまで出さない。
+ * 同期が取れたあとは、先頭が合わなくなるまでヘッダーの長さのとおりに進む。
+ *
+ * 出すパケットの中身は、渡されたチャンクか前の残りの一部を指す (コピーしない)。
+ * **次の `feed` より後まで持つならコピーすること** (`PacketStream` と同じ)
+ */
+export class TlvStream {
+    rest = new Uint8Array(0);
+    synced = false;
+    /** 合わせるために読み飛ばしたバイトの合計 */
+    skipped = 0;
+    /** 同期を失って合わせ直した回数 */
+    resyncs = 0;
+    *feed(chunk) {
+        let data = chunk;
+        if (this.rest.length > 0) {
+            /*
+             * 前の残りが同期の取れたパケットの途中なら、そのパケットだけをチャンクの先頭と繋ぐ。
+             * **チャンクの全体は写さない** (38 Mbps を毎回写すことになる)
+             */
+            const head = concatBytes([this.rest, chunk.subarray(0, HEADER)]);
+            if (this.synced && head.length >= HEADER && looksLikeHead(head, 0)) {
+                const used = HEADER + u16(head, 2) - this.rest.length;
+                if (used > chunk.length) {
+                    this.rest = concatBytes([this.rest, chunk]);
+                    return;
+                }
+                const packet = concatBytes([this.rest, chunk.subarray(0, used)]);
+                yield {
+                    type: packet[1],
+                    payload: packet.subarray(HEADER),
+                    bytes: packet,
+                };
+                data = chunk.subarray(used);
+            }
+            else
+                data = concatBytes([this.rest, chunk]);
+        }
+        let at = 0;
+        for (;;) {
+            if (!this.synced) {
+                const found = findHead(data, at);
+                // 見つからなければ、次のチャンクと繋げて探せるよう末尾の 3 バイトだけを残す
+                const next = found?.at ?? Math.max(at, data.length - (HEADER - 1));
+                this.skipped += next - at;
+                at = next;
+                if (found === null || found.wait)
+                    break;
+                this.synced = true;
+            }
+            if (at + HEADER > data.length)
+                break;
+            if (!looksLikeHead(data, at)) {
+                this.synced = false;
+                this.resyncs++;
+                continue;
+            }
+            const end = at + HEADER + u16(data, at + 2);
+            if (end > data.length)
+                break;
+            yield {
+                type: data[at + 1],
+                payload: data.subarray(at + HEADER, end),
+                bytes: data.subarray(at, end),
+            };
+            at = end;
+        }
+        this.rest = data.slice(at);
+    }
+}
+/** `from` から、先頭と次のパケットの先頭がどちらも合う位置を探す */
+function findHead(data, from) {
+    for (let at = from; at + HEADER <= data.length; at++) {
+        if (!looksLikeHead(data, at))
+            continue;
+        const next = at + HEADER + u16(data, at + 2);
+        if (next + 2 > data.length)
+            return { at, wait: true };
+        if (looksLikeHead(data, next))
+            return { at, wait: false };
+    }
+    return null;
+}

package/dist/ttml.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 4K の放送 (MMT/TLV) の字幕 (ARIB STD-B62 の TTML) を、字幕の文字の配置 (`caption-text.ts`) にする。
+ * TS の字幕の `b24caption.ts` に当たり、受け側は TS の字幕と同じように描くだけで済む。
+ *
+ * 字幕の文書は MPU 1 つに 1 つ来る (`mmt-media.ts` の `CaptionUnit`)。文書の中の時刻 (begin・end・dur) は、
+ * MPU の最初の提示時刻からのずれとして読む (推定。字幕のパケットは実機の録りにまだ来ていない)。
+ *
+ * 読むのは文字・位置 (region の origin・extent、textAlign・displayAlign)・大きさ (fontSize・lineHeight)・
+ * 色 (color・backgroundColor・textOutline)・太字・斜体・下線・ルビ。画像を参照する字幕 (PNG) と
+ * 縦書き・アニメーション (set) は読まない
+ */
+import { type CaptionPage } from "./caption-text.js";
+/** 字幕 1 枚と、出す時刻 (90 kHz) */
+export interface TimedCaptionPage {
+    at: number;
+    page: CaptionPage;
+}
+/**
+ * TTML の文書を、出す時刻ごとの字幕の文字の配置にする。`start` は文書の時刻の始まり (MPU の最初の提示時刻、90 kHz)。
+ *
+ * 段落 (p) の出る・消える時刻ごとに 1 枚を作る (`CaptionPage` は前の 1 枚を丸ごと置き換えるので、
+ * その時刻に出ている段落を全部並べる)。最初の 1 枚は `start` で、何も出ていなければ空 (前の文書の字幕を消す)。
+ * 読めない文書は空の並びを返す
+ */
+export declare function ttmlPages(document: string, start: number): TimedCaptionPage[];

package/dist/ttml.js

@@ -0,0 +1,455 @@
+/**
+ * 4K の放送 (MMT/TLV) の字幕 (ARIB STD-B62 の TTML) を、字幕の文字の配置 (`caption-text.ts`) にする。
+ * TS の字幕の `b24caption.ts` に当たり、受け側は TS の字幕と同じように描くだけで済む。
+ *
+ * 字幕の文書は MPU 1 つに 1 つ来る (`mmt-media.ts` の `CaptionUnit`)。文書の中の時刻 (begin・end・dur) は、
+ * MPU の最初の提示時刻からのずれとして読む (推定。字幕のパケットは実機の録りにまだ来ていない)。
+ *
+ * 読むのは文字・位置 (region の origin・extent、textAlign・displayAlign)・大きさ (fontSize・lineHeight)・
+ * 色 (color・backgroundColor・textOutline)・太字・斜体・下線・ルビ。画像を参照する字幕 (PNG) と
+ * 縦書き・アニメーション (set) は読まない
+ */
+import { CAPTION_TEXT_VERSION, } from "./caption-text.js";
+import { CLOCK } from "./mmt-media.js";
+const ENTITIES = {
+    lt: "<",
+    gt: ">",
+    amp: "&",
+    quot: '"',
+    apos: "'",
+};
+function unescape(text) {
+    return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (whole, name) => {
+        const code = name;
+        if (code.startsWith("#x") || code.startsWith("#X"))
+            return String.fromCodePoint(parseInt(code.slice(2), 16));
+        if (code.startsWith("#"))
+            return String.fromCodePoint(Number(code.slice(1)));
+        return ENTITIES[code] ?? whole;
+    });
+}
+const localName = (name) => name.slice(name.indexOf(":") + 1);
+/** 字幕の文書を読むだけの小さな XML の読み取り。壊れていれば null */
+function parseXml(text) {
+    const root = { name: "", attributes: {}, children: [] };
+    const stack = [root];
+    const token = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!\[CDATA\[([\s\S]*?)\]\]>|<![^>]*>|<\/([^\s>]+)\s*>|<([^\s/>]+)((?:\s+[^\s=]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>|([^<]+)/g;
+    for (const match of text.matchAll(token)) {
+        const top = stack.at(-1);
+        const [, cdata, close, open, attributes, selfClosing, chars] = match;
+        if (cdata !== undefined)
+            top.children.push(cdata);
+        else if (chars !== undefined)
+            top.children.push(unescape(chars));
+        else if (close !== undefined) {
+            if (stack.length < 2 || top.name !== localName(close))
+                return null;
+            stack.pop();
+        }
+        else if (open !== undefined) {
+            const element = {
+                name: localName(open),
+                attributes: {},
+                children: [],
+            };
+            for (const [, key = "", , a, b] of (attributes ?? "").matchAll(/([^\s=]+)\s*=\s*("([^"]*)"|'([^']*)')/g))
+                element.attributes[localName(key)] = unescape(a ?? b ?? "");
+            top.children.push(element);
+            if (selfClosing !== "/")
+                stack.push(element);
+        }
+    }
+    const tt = root.children.find((c) => typeof c !== "string");
+    return stack.length === 1 && tt?.name === "tt" ? tt : null;
+}
+function* elements(node, name) {
+    for (const child of node.children) {
+        if (typeof child === "string")
+            continue;
+        if (child.name === name)
+            yield child;
+        yield* elements(child, name);
+    }
+}
+/** 時刻の書き方 (`00:00:01.500`・`00:00:01:15`・`1.5s`・`1500ms`・`90f`) を秒に。読めなければ null */
+function seconds(value, frameRate) {
+    if (value === undefined)
+        return null;
+    const clock = /^(\d+):(\d{2}):(\d{2}(?:\.\d+)?)(?::(\d+(?:\.\d+)?))?$/.exec(value.trim());
+    if (clock !== null) {
+        const [, h = "0", m = "0", s = "0", f] = clock;
+        return (Number(h) * 3600 +
+            Number(m) * 60 +
+            Number(s) +
+            (f === undefined ? 0 : Number(f) / frameRate));
+    }
+    const offset = /^(\d+(?:\.\d+)?)(h|m|s|ms|f)$/.exec(value.trim());
+    if (offset === null)
+        return null;
+    const [, count = "0", unit] = offset;
+    const scale = {
+        h: 3600,
+        m: 60,
+        s: 1,
+        ms: 0.001,
+        f: 1 / frameRate,
+    }[unit];
+    return Number(count) * scale;
+}
+/** 名前で書く色 (TTML の名前の色) */
+const NAMED = {
+    transparent: "#00000000",
+    black: "#000000ff",
+    silver: "#c0c0c0ff",
+    gray: "#808080ff",
+    white: "#ffffffff",
+    maroon: "#800000ff",
+    red: "#ff0000ff",
+    purple: "#800080ff",
+    fuchsia: "#ff00ffff",
+    magenta: "#ff00ffff",
+    green: "#008000ff",
+    lime: "#00ff00ff",
+    olive: "#808000ff",
+    yellow: "#ffff00ff",
+    navy: "#000080ff",
+    blue: "#0000ffff",
+    teal: "#008080ff",
+    aqua: "#00ffffff",
+    cyan: "#00ffffff",
+};
+const hex2 = (value) => Math.max(0, Math.min(255, Math.round(value)))
+    .toString(16)
+    .padStart(2, "0");
+/** 色を `#rrggbbaa` に。読めなければ null */
+function color(value) {
+    if (value === undefined)
+        return null;
+    const text = value.trim().toLowerCase();
+    if (/^#[0-9a-f]{6}$/.test(text))
+        return `${text}ff`;
+    if (/^#[0-9a-f]{8}$/.test(text))
+        return text;
+    const rgb = /^rgba?\(([^)]*)\)$/.exec(text);
+    if (rgb !== null) {
+        const [r = 0, g = 0, b = 0, a = 255] = (rgb[1] ?? "")
+            .split(",")
+            .map(Number);
+        return `#${hex2(r)}${hex2(g)}${hex2(b)}${hex2(a)}`;
+    }
+    return NAMED[text] ?? null;
+}
+/** 長さ 1 つ (`12px`・`50%`・`1.5c`)。% は `whole` に対して。読めなければ null */
+function length(value, whole, cell) {
+    const match = /^(-?\d+(?:\.\d+)?)(px|%|c|em)$/.exec(value.trim());
+    if (match === null)
+        return null;
+    const number = Number(match[1]);
+    switch (match[2]) {
+        case "px":
+            return number;
+        case "%":
+            return (number / 100) * whole;
+        default:
+            return number * cell;
+    }
+}
+/** 2 つの長さ (`x y`・`幅 高さ`)。1 つしか無ければ両方に使う */
+function pair(value, frame, wholeX = frame.width, wholeY = frame.height) {
+    if (value === undefined)
+        return null;
+    const parts = value.trim().split(/\s+/);
+    const x = length(parts[0] ?? "", wholeX, frame.width / frame.columns);
+    const y = length(parts[1] ?? parts[0] ?? "", wholeY, frame.height / frame.rows);
+    return x === null || y === null ? null : [x, y];
+}
+/** `style` で参照した名前の付いた style を、参照の順に重ねる (style がさらに参照するものも先に) */
+function referenced(ids, context, seen = new Set()) {
+    let out = {};
+    for (const id of (ids ?? "").split(/\s+/)) {
+        const style = context.styles.get(id);
+        if (style === undefined || seen.has(id))
+            continue;
+        seen.add(id);
+        out = { ...out, ...referenced(style["style"], context, seen), ...style };
+    }
+    return out;
+}
+/** 要素の見た目。親から受け継いだものに、参照した style と要素の属性を重ねる */
+function styleOf(element, inherited, context) {
+    return {
+        ...inherited,
+        ...referenced(element.attributes["style"], context),
+        ...element.attributes,
+    };
+}
+/** p の中身を行に分ける。xml:space が default なら、空白の並びを 1 つにして行の端を落とす */
+function lines(p, style, context) {
+    const out = [[]];
+    const walk = (node, inherited) => {
+        if (typeof node === "string") {
+            const preserve = inherited["space"] === "preserve";
+            const text = preserve ? node : node.replace(/\s+/g, " ");
+            for (const char of text)
+                out.at(-1).push({ char, style: inherited });
+            return;
+        }
+        if (node.name === "br") {
+            out.push([]);
+            return;
+        }
+        if (node.name !== "span")
+            return;
+        const own = styleOf(node, inherited, context);
+        // ルビの入れ物: 親字 (base) の並びと、ルビ (text) を組にする
+        if (own["ruby"] === "container") {
+            const parts = node.children.filter((c) => typeof c !== "string");
+            const find = (kind) => parts.find((c) => styleOf(c, own, context)["ruby"] === kind) ??
+                parts
+                    .filter((c) => styleOf(c, own, context)["ruby"] === `${kind}Container`)
+                    .flatMap((c) => c.children.filter((x) => typeof x !== "string"))[0];
+            const base = find("base");
+            const ruby = find("text");
+            const before = out.at(-1).length;
+            if (base !== undefined)
+                walk(base, own);
+            const added = out.at(-1).length - before;
+            const first = out.at(-1)[before];
+            if (ruby !== undefined && first !== undefined && added > 0)
+                first.ruby = { text: textOf(ruby).trim(), count: added };
+            return;
+        }
+        for (const child of node.children)
+            walk(child, own);
+    };
+    for (const child of p.children)
+        walk(child, style);
+    return out.map((line) => style["space"] === "preserve" ? line : trimLine(line));
+}
+function textOf(node) {
+    return typeof node === "string" ? node : node.children.map(textOf).join("");
+}
+function trimLine(line) {
+    let start = 0;
+    let end = line.length;
+    while (start < end && line[start].char === " ")
+        start++;
+    while (end > start && line[end - 1].char === " ")
+        end--;
+    return line.slice(start, end);
+}
+/** 半角の字 (ASCII・半角カナ)。区画の幅を半分にする */
+function narrow(char) {
+    const code = char.codePointAt(0);
+    return code < 0x7f || (code >= 0xff61 && code <= 0xff9f);
+}
+/** 見た目から、字の大きさ (縦) と横の縮め方 */
+function fontSize(style, frame) {
+    const cell = frame.height / frame.rows;
+    const parts = (style["fontSize"] ?? "1c").trim().split(/\s+/);
+    const height = length(parts[1] ?? parts[0] ?? "", cell, cell) ?? cell;
+    const width = parts[1] === undefined
+        ? height
+        : (length(parts[0] ?? "", cell, cell) ?? height);
+    return [height, height > 0 ? width / height : 1];
+}
+function lineHeight(style, size, frame) {
+    const value = style["lineHeight"];
+    if (value === undefined || value === "normal")
+        return size * 1.2;
+    return length(value, size, frame.height / frame.rows) ?? size * 1.2;
+}
+/** 1 行を区画に並べた run にする。`x`・`y` は行の左上 */
+function lineRuns(line, x, y, height, frame) {
+    const runs = [];
+    const rubies = [];
+    let at = x;
+    line.forEach((glyph, i) => {
+        const [size, scaleX] = fontSize(glyph.style, frame);
+        const w = glyphWidth(glyph.char, glyph.style, frame);
+        const run = runOf(glyph.style, glyph.char, at, y, w, height, size, scaleX);
+        const last = runs.at(-1);
+        if (last !== undefined &&
+            sameLook(last, run) &&
+            Math.abs(last.x + last.w * [...last.text].length - at) < 1e-6)
+            last.text += glyph.char;
+        else
+            runs.push(run);
+        if (glyph.ruby !== undefined) {
+            // 親字の並びの幅の真ん中に、半分の大きさで、行の上へはみ出して置く
+            const baseWidth = line
+                .slice(i, i + glyph.ruby.count)
+                .reduce((sum, g) => sum + glyphWidth(g.char, g.style, frame), 0);
+            const rubySize = size / 2;
+            const chars = [...glyph.ruby.text];
+            const widths = chars.map((c) => rubySize * scaleX * (narrow(c) ? 0.5 : 1));
+            let rx = at + (baseWidth - widths.reduce((a, b) => a + b, 0)) / 2;
+            chars.forEach((char, k) => {
+                const rw = widths[k];
+                const ruby = runOf(glyph.style, char, rx, y - rubySize, rw, rubySize, rubySize, scaleX);
+                ruby.ruby = true;
+                ruby.bg = "#00000000";
+                rubies.push(ruby);
+                rx += rw;
+            });
+        }
+        at += w;
+    });
+    return [...runs, ...rubies];
+}
+/** 1 字の区画の幅 */
+function glyphWidth(char, style, frame) {
+    const [size, scaleX] = fontSize(style, frame);
+    return size * scaleX * (narrow(char) ? 0.5 : 1);
+}
+function runOf(style, text, x, y, w, h, size, scaleX) {
+    const run = {
+        x,
+        y,
+        w,
+        h,
+        fx: 0,
+        fy: (h - size) / 2,
+        size,
+        scaleX,
+        text,
+        fg: color(style["color"]) ?? "#ffffffff",
+        bg: color(style["backgroundColor"]) ?? "#00000000",
+    };
+    const outline = style["textOutline"]?.trim().split(/\s+/) ?? ["none"];
+    if (outline[0] !== "none")
+        run.stroke = color(outline[0]) ?? run.fg;
+    if (style["fontWeight"] === "bold")
+        run.bold = true;
+    if (style["fontStyle"] === "italic" || style["fontStyle"] === "oblique")
+        run.italic = true;
+    if (style["textDecoration"]?.includes("underline") === true)
+        run.underline = true;
+    return run;
+}
+function sameLook(a, b) {
+    return (a.y === b.y &&
+        a.w === b.w &&
+        a.h === b.h &&
+        a.size === b.size &&
+        a.scaleX === b.scaleX &&
+        a.fg === b.fg &&
+        a.bg === b.bg &&
+        a.stroke === b.stroke &&
+        a.bold === b.bold &&
+        a.italic === b.italic &&
+        a.underline === b.underline &&
+        a.ruby === undefined &&
+        b.ruby === undefined);
+}
+/** p を、region の中に置いた run にする */
+function layout(p, style, context) {
+    const { frame } = context;
+    const region = context.regions.get(style["region"] ?? "");
+    const regionStyle = region === undefined ? {} : styleOf(region, {}, context);
+    const merged = { ...regionStyle, ...style };
+    const [x, y] = pair(regionStyle["origin"], frame) ?? [0, 0];
+    const [width, height] = pair(regionStyle["extent"], frame) ?? [
+        frame.width - x,
+        frame.height - y,
+    ];
+    const rows = lines(p, merged, context).filter((line) => line.length > 0);
+    const heights = rows.map((line) => Math.max(...line.map((g) => lineHeight(g.style, fontSize(g.style, frame)[0], frame))));
+    const total = heights.reduce((sum, h) => sum + h, 0);
+    const align = merged["displayAlign"];
+    let top = y +
+        (align === "after"
+            ? height - total
+            : align === "center"
+                ? (height - total) / 2
+                : 0);
+    const runs = [];
+    rows.forEach((line, i) => {
+        const lineWidth = line.reduce((sum, g) => sum + glyphWidth(g.char, g.style, frame), 0);
+        const textAlign = merged["textAlign"];
+        const left = x +
+            (textAlign === "center"
+                ? (width - lineWidth) / 2
+                : textAlign === "right" || textAlign === "end"
+                    ? width - lineWidth
+                    : 0);
+        runs.push(...lineRuns(line, left, top, heights[i], frame));
+        top += heights[i];
+    });
+    return runs;
+}
+/**
+ * TTML の文書を、出す時刻ごとの字幕の文字の配置にする。`start` は文書の時刻の始まり (MPU の最初の提示時刻、90 kHz)。
+ *
+ * 段落 (p) の出る・消える時刻ごとに 1 枚を作る (`CaptionPage` は前の 1 枚を丸ごと置き換えるので、
+ * その時刻に出ている段落を全部並べる)。最初の 1 枚は `start` で、何も出ていなければ空 (前の文書の字幕を消す)。
+ * 読めない文書は空の並びを返す
+ */
+export function ttmlPages(document, start) {
+    const tt = parseXml(document);
+    if (tt === null)
+        return [];
+    const [columns = 32, rows = 15] = (tt.attributes["cellResolution"] ?? "32 15")
+        .split(/\s+/)
+        .map(Number);
+    const [width = 1920, height = 1080] = /^\s*(\d+(?:\.\d+)?)px\s+(\d+(?:\.\d+)?)px\s*$/
+        .exec(tt.attributes["extent"] ?? "")
+        ?.slice(1)
+        .map(Number) ?? [1920, 1080];
+    const context = {
+        frame: { width, height, columns, rows },
+        frameRate: Number(tt.attributes["frameRate"] ?? 30) || 30,
+        styles: new Map(),
+        regions: new Map(),
+    };
+    for (const style of elements(tt, "style")) {
+        const id = style.attributes["id"];
+        if (id !== undefined)
+            context.styles.set(id, style.attributes);
+    }
+    for (const region of elements(tt, "region")) {
+        const id = region.attributes["id"];
+        if (id !== undefined)
+            context.regions.set(id, region);
+    }
+    const paragraphs = [];
+    /** 時刻は親の始まりからのずれ (par)。end も dur も無ければ親の終わりまで */
+    const walk = (node, inherited, begin, end) => {
+        const style = styleOf(node, inherited, context);
+        const own = seconds(node.attributes["begin"], context.frameRate);
+        const from = begin + (own ?? 0);
+        const until = seconds(node.attributes["end"], context.frameRate);
+        const dur = seconds(node.attributes["dur"], context.frameRate);
+        const to = Math.min(end, until !== null ? begin + until : Infinity, dur !== null ? from + dur : Infinity);
+        if (node.name === "p") {
+            paragraphs.push({
+                begin: from,
+                end: to,
+                runs: layout(node, style, context),
+            });
+            return;
+        }
+        for (const child of node.children)
+            if (typeof child !== "string")
+                walk(child, style, from, to);
+    };
+    const body = [...elements(tt, "body")][0];
+    if (body !== undefined)
+        walk(body, {}, 0, Infinity);
+    const times = [
+        ...new Set([0, ...paragraphs.flatMap((p) => [p.begin, p.end])]),
+    ]
+        .filter((t) => Number.isFinite(t) && t >= 0)
+        .sort((a, b) => a - b);
+    return times.map((t) => ({
+        at: start + Math.round(t * CLOCK),
+        page: {
+            v: CAPTION_TEXT_VERSION,
+            plane: [width, height],
+            duration: null,
+            runs: paragraphs
+                .filter((p) => p.begin <= t && t < p.end)
+                .flatMap((p) => p.runs),
+        },
+    }));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danything/arib",
-  "version": "2.0.0",
-  "description": "日本のデジタル放送 (ARIB) の TS を読む: PSI・PES・EIT・ARIB の文字・字幕・データ放送",
+  "version": "2.2.0",
+  "description": "日本のデジタル放送 (ARIB) の TS と MMT/TLV を読む: PSI・PES・EIT・ARIB の文字・字幕・データ放送、TLV・MMTP・MMT-SI・MH-EIT",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,7 +16,9 @@
     "epg",
     "b24",
     "caption",
-    "bml"
+    "bml",
+    "mmt",
+    "tlv"
   ],
   "type": "module",
   "sideEffects": false,