@danything/arib 0.0.0-stage → 1.0.0

package/dist/bml.js

@@ -0,0 +1,510 @@
+/**
+ * データ放送 (ARIB STD-B24 の BML) をデコードする。**1局に絞った TS を食わせると、
+ * 組み立て終わったファイルが出てくる。**
+ *
+ *     TS → PAT → PMT → データ符号化方式記述子 (0xFD) の付いた ES
+ *                       → DII/DDB (カルーセル) → モジュール → ファイル
+ *
+ * ## なぜ自前なのか
+ *
+ * **運び方は衛星のロゴと同じ DSM-CC** で、denpa はそれを既に持っている
+ * ([dsmcc.ts](dsmcc.ts) / [logo-dsmcc.ts](https://github.com/danything/denpa/blob/main/src/lib/ts/logo-dsmcc.ts))。
+ * [web-bml](https://github.com/otya128/web-bml) の `decode_ts.ts` は使わない — 要るのは
+ * その一部だけで、残り (EIT/SDT/NIT・字幕の PES) は自前で読んでおり
+ * ([eit.ts](eit.ts) / [psi.ts](psi.ts) / [b24caption.ts](b24caption.ts))、`@chinachu/aribts` も抱えずに済む。
+ *
+ * **出す形式は web-bml の頃のまま** ([bml-protocol.ts](bml-protocol.ts))。録画の隣の
+ * `.bml.jsonl` がこの形式で残っているので、変えると前に録ったものが読めなくなる。
+ * モジュールの中身 (multipart) は [multipart.ts](multipart.ts) がデコードする。
+ */
+import { Buffer } from "node:buffer";
+import { inflateSync } from "node:zlib";
+import { u16, u32 } from "./bytes.js";
+import { dataEventIdOf, MAX_MODULE_SIZE, ModuleBuilder, parseDdb, parseDii, TABLE_DII, TABLE_STREAM_DESCRIPTOR, } from "./dsmcc.js";
+import { parseTimeTable, PID_TIME } from "./eit.js";
+import { parseMediaType, readEntity } from "./multipart.js";
+import { descriptors, packetPid, PacketStream, pmtStreams, PmtTracker, SectionAssembler, } from "./psi.js";
+const DESC_STREAM_IDENTIFIER = 0x52;
+/** データ符号化方式記述子 (STD-B10 第2部 6.2.20) */
+const DESC_DATA_COMPONENT = 0xfd;
+/**
+ * BML が載っている符号化方式 (STD-B10 第2部 付録J 表J-1)。
+ * 0x0C/0x0D が地上波、0x07 が BS、0x0B が CS
+ */
+const BXML_COMPONENT_IDS = new Set([0x07, 0x0b, 0x0c, 0x0d]);
+/** zlib。Compression Type 記述子で運用されるのはこれだけ */
+const COMPRESSION_ZLIB = 0;
+/**
+ * データ符号化方式記述子の後半を読む。
+ *
+ * 地上波は TR-B14 第二分冊 2.1.4 表2-3、BS/CS は TR-B15 第一分冊 5.1.5 表5-4。
+ *
+ * **`data_component_id` は16ビット** (aribts は8ビットで読んでいる)。
+ */
+export function parseBxmlInfo(data) {
+    let at = 0;
+    // 00 のみ運用 (データカルーセル伝送方式およびイベントメッセージ伝送方式)
+    const transmissionFormat = (data[at] >> 6) & 0b11;
+    // component_tag=0x40 のとき必ず1。startup.xml が最初に起動される
+    const entryPointFlag = ((data[at] >> 5) & 1) === 1;
+    const info = { transmissionFormat, entryPointFlag };
+    if (entryPointFlag) {
+        const autoStartFlag = ((data[at] >> 4) & 1) === 1;
+        /*
+         * 画面の大きさ。運用されるのは 0011 (960x540)、0100 (640x480 16:9)、
+         * 0101 (640x480 4:3) の3つ
+         */
+        const documentResolution = data[at] & 0x0f;
+        at++;
+        const useXML = ((data[at] >> 7) & 1) === 1;
+        const defaultVersionFlag = ((data[at] >> 6) & 1) === 1;
+        // BS/CS では 0 のとき単独視聴不可。地上波は常に1
+        const independentFlag = ((data[at] >> 5) & 1) === 1;
+        const styleForTVFlag = ((data[at] >> 4) & 1) === 1;
+        at++;
+        // 既定は BS の 1.0。地上波は3、CS は2が入ってくる
+        info.entryPointInfo = {
+            autoStartFlag,
+            documentResolution,
+            useXML,
+            defaultVersionFlag,
+            independentFlag,
+            styleForTVFlag,
+            bmlMajorVersion: 1,
+            bmlMinorVersion: 0,
+        };
+        if (!defaultVersionFlag) {
+            info.entryPointInfo.bmlMajorVersion = u16(data, at);
+            info.entryPointInfo.bmlMinorVersion = u16(data, at + 2);
+            at += 4;
+            // 運用されない
+            if (useXML) {
+                info.entryPointInfo.bxmlMajorVersion = u16(data, at);
+                info.entryPointInfo.bxmlMinorVersion = u16(data, at + 2);
+                at += 4;
+            }
+        }
+    }
+    else {
+        at++;
+    }
+    if (transmissionFormat === 0) {
+        // additional_arib_carousel_info (STD-B24 第三分冊 第三編 C.1)
+        const dataEventId = (data[at] >> 4) & 0x0f;
+        const eventSectionFlag = ((data[at] >> 3) & 1) === 1;
+        at++;
+        const ondemandRetrievalFlag = ((data[at] >> 7) & 1) === 1;
+        const fileStorableFlag = ((data[at] >> 6) & 1) === 1;
+        const startPriority = (data[at] >> 5) & 1;
+        info.additionalAribCarouselInfo = {
+            dataEventId,
+            eventSectionFlag,
+            ondemandRetrievalFlag,
+            fileStorableFlag,
+            startPriority,
+        };
+    }
+    return info;
+}
+/**
+ * PMT から ES を並べる。**部品タグ (component_tag) を持たない ES は数に入れない** —
+ * データ放送は「何番の部品か」でしか物を指せないので、番号の無いものは指しようがない。
+ */
+function parsePmt(section) {
+    const components = [];
+    for (const [streamType, pid, info] of pmtStreams(section)) {
+        let componentId;
+        let dataComponentId;
+        let bxmlInfo;
+        for (const [tag, descriptor] of descriptors(info)) {
+            if (tag === DESC_STREAM_IDENTIFIER && descriptor.length >= 1)
+                componentId = descriptor[0];
+            else if (tag === DESC_DATA_COMPONENT && descriptor.length >= 2) {
+                dataComponentId = u16(descriptor, 0);
+                if (BXML_COMPONENT_IDS.has(dataComponentId))
+                    bxmlInfo = parseBxmlInfo(descriptor.subarray(2));
+            }
+        }
+        if (componentId === undefined)
+            continue;
+        components.push({
+            componentId,
+            pid,
+            streamType,
+            ...(dataComponentId === undefined ? {} : { dataComponentId }),
+            ...(bxmlInfo === undefined ? {} : { bxmlInfo }),
+        });
+    }
+    return components;
+}
+/** `at` の下位1ビットと続く4バイトで 33 ビット (STC・NPT) */
+const u33 = (data, at) => (data[at] & 1) * 0x100000000 + u32(data, at + 1);
+/** ストリーム記述子 (table_id 0x3D)。NPT と イベントメッセージが載っている */
+function parseEsEvents(section) {
+    const events = [];
+    const length = u16(section, 1) & 0x0fff;
+    const body = section.subarray(8, Math.min(3 + length - 4, section.length));
+    for (const [tag, descriptor] of descriptors(body)) {
+        if (tag === 0x17 && descriptor.length >= 18) {
+            // NPT 参照記述子。放送の時計と番組内の時刻を結び付ける
+            events.push({
+                type: "nptReference",
+                postDiscontinuityIndicator: (descriptor[0] & 0x80) !== 0,
+                dsmContentId: descriptor[0] & 0x7f,
+                STCReference: u33(descriptor, 1),
+                NPTReference: u33(descriptor, 9),
+                scaleNumerator: u16(descriptor, 14),
+                scaleDenominator: u16(descriptor, 16),
+            });
+        }
+        else if (tag === 0x40 && descriptor.length >= 11) {
+            // 汎用イベントメッセージ記述子。運用されるのは time_mode 0 と 2 だけ
+            const timeMode = descriptor[2];
+            const message = {
+                eventMessageGroupId: (u16(descriptor, 0) >> 4) & 0x0fff,
+                eventMessageType: descriptor[8],
+                eventMessageId: u16(descriptor, 9),
+                privateDataByte: [...descriptor.subarray(11)],
+            };
+            if (timeMode === 0)
+                events.push({ type: "immediateEvent", timeMode: 0, ...message });
+            else if (timeMode === 2)
+                events.push({
+                    type: "nptEvent",
+                    timeMode: 2,
+                    eventMessageNPT: u33(descriptor, 3),
+                    ...message,
+                });
+        }
+    }
+    return events;
+}
+/**
+ * **DII に載ったモジュールが来なければ諦める。** 最後にブロックが増えてから、DII が
+ * この回数繰り返し、しかもカルーセルが一覧の大きさのこの倍数ぶん流れたら、もう来ないとみなす。
+ * 両方を見るのは、DII の繰り返しはカルーセルの一周より短いことがあり (回数だけだと大きい
+ * カルーセルの途中で諦める)、よく使うモジュールは一周に何度も流れる (バイト数だけだと一周を
+ * 短く見積もる) ため
+ */
+const GIVE_UP_ROUNDS = 4;
+/**
+ * 1つの `BmlDecoder` で同時に組み立てるモジュールの大きさの合計の上限 (64MiB)。
+ * 1つずつは `MAX_MODULE_SIZE` に収まっても、たくさん並べた DII や ES でメモリを使い切らせられる。
+ * 実際のカルーセルは全部で数 MB に収まる
+ */
+const MAX_CAROUSEL_SIZE = 64 * 1024 * 1024;
+/** `Component.done` に置く印。モジュールのバージョンとカルーセルの回 (dataEventId) の組 */
+function doneMark(component, version) {
+    return `${version}:${component.dataEventId}`;
+}
+/**
+ * 1局に絞った TS を食わせると、データ放送の通知が出てくる。
+ *
+ * **1つの選局に1つ。** 局を変えたら作り直す — カルーセルは局ごとに別物で、
+ * 組み立て中のものを持ち越すと混ざる。
+ */
+export class BmlDecoder {
+    send;
+    packets = new PacketStream();
+    /** **1局に絞ったあとを食わせる前提。** 入っているサービスは1つなので、最初の局の PMT を追う */
+    pmt = new PmtTracker();
+    // TDT は CRC を持たない。DSM-CC と同じ理由で 'syntax' で受ける
+    time = new SectionAssembler(PID_TIME, "syntax");
+    /** カルーセルが流れている ES。PID ごと */
+    components = new Map();
+    /** 最後に配った PMT。**変わったときだけ配る** */
+    sent = null;
+    constructor(send) {
+        this.send = send;
+    }
+    /** 1局に絞った TS を食わせる */
+    feed(chunk) {
+        for (const packet of this.packets.feed(chunk))
+            this.feedPacket(packet);
+    }
+    /**
+     * 切り分け済みのパケットを1つ。ライブは同じ TS を時計や Hybridcast とも
+     * 分け合うので、切り分けは1回で済ませて配る (denpa の `server/live.ts` の `tap`)。
+     *
+     * **PID で行き先を引く。** 組み立て役を全部に回していた頃は、データ放送と
+     * 関係ない映像のパケットのたびにカルーセルの数だけ呼んでいた。
+     *
+     * `packet` は呼び手の塊の上の窓 (`psi.ts` の `PacketStream`)。**返ったあとまで
+     * 持つなら写すこと** — 塊の入れ物は使い回される
+     */
+    feedPacket(packet) {
+        const pid = packetPid(packet);
+        // 同じ PID を2役が名乗ることもあるので、else でつながない
+        for (const section of this.pmt.feed(packet, pid))
+            this.onPmt(section);
+        if (pid === PID_TIME)
+            for (const section of this.time.feed(packet))
+                this.onTime(section);
+        const component = this.components.get(pid);
+        if (component !== undefined) {
+            for (const section of component.sections.feed(packet))
+                this.onCarousel(component, section);
+        }
+    }
+    onPmt(section) {
+        const components = parsePmt(section);
+        if (components.length === 0)
+            return;
+        /*
+         * 放送は同じ表を何度も送る。**変わったときだけ配る** — 受け側は
+         * PMT が来るたびに画面を組み直すので、そのまま通すと出っ放しになる
+         */
+        const shape = JSON.stringify(components);
+        if (this.sent !== shape) {
+            this.sent = shape;
+            this.send({ type: "pmt", components });
+        }
+        for (const component of components) {
+            // カルーセルが流れているのは、BML の符号化方式が付いた ES だけ
+            if (component.bxmlInfo === undefined)
+                continue;
+            if (this.components.has(component.pid))
+                continue;
+            this.components.set(component.pid, {
+                componentId: component.componentId,
+                // DSM-CC は section_syntax_indicator が立たないことがある (psi.ts)
+                sections: new SectionAssembler(component.pid, "syntax"),
+                transactionId: null,
+                dataEventId: -1,
+                building: new Map(),
+                done: new Map(),
+                dii: null,
+                size: 0,
+                abandoned: new Set(),
+            });
+        }
+    }
+    /** TDT / TOT。読み方は [eit.ts](eit.ts) にまとめてある */
+    onTime(section) {
+        const at = parseTimeTable(section);
+        if (at !== null)
+            this.send({ type: "currentTime", timeUnixMillis: at });
+    }
+    onCarousel(component, section) {
+        if (section[0] === TABLE_STREAM_DESCRIPTOR) {
+            const extension = u16(section, 3);
+            this.send({
+                type: "esEventUpdated",
+                componentId: component.componentId,
+                events: parseEsEvents(section),
+                dataEventId: extension >> 12,
+            });
+            return;
+        }
+        if (section[0] === TABLE_DII)
+            this.onDii(component, section);
+        else
+            this.onDdb(component, section);
+    }
+    onDii(component, section) {
+        const dii = parseDii(section);
+        if (dii === null)
+            return;
+        // 同じカルーセルが回ってきただけ。組み立て中のものを捨てない
+        if (component.transactionId === dii.transactionId) {
+            for (const held of component.building.values())
+                held.quietDiis++;
+            this.giveUp(component);
+            return;
+        }
+        component.transactionId = dii.transactionId;
+        /*
+         * **番組が変わったら覚えていたものを捨てる。** dataEventId はカルーセルの
+         * 「回」で、ここが変わると前の番組のファイルは使えない
+         */
+        const dataEventId = dataEventIdOf(dii.downloadId);
+        if (component.dataEventId !== dataEventId) {
+            component.dataEventId = dataEventId;
+            component.done.clear();
+        }
+        component.building.clear();
+        component.abandoned.clear();
+        component.dii = dii;
+        component.size = 0;
+        // ほかの ES で組み立て中のものと合わせて `MAX_CAROUSEL_SIZE` に収める
+        let budget = MAX_CAROUSEL_SIZE;
+        for (const other of this.components.values())
+            if (other !== component)
+                budget -= other.size;
+        for (const module of dii.modules) {
+            /*
+             * **大きすぎるモジュールは組み立てない。** 来ないものとして一覧から外す
+             * (受け側が待ち続けないように)
+             */
+            if (module.moduleSize > MAX_MODULE_SIZE ||
+                component.size + module.moduleSize > budget) {
+                component.abandoned.add(module.moduleId);
+                continue;
+            }
+            component.size += module.moduleSize;
+            component.building.set(module.moduleId, {
+                module,
+                builder: new ModuleBuilder(module.moduleVersion, module.moduleSize, dii.blockSize),
+                quietDiis: 0,
+                quietBytes: 0,
+            });
+        }
+        this.sendList(component);
+        // 大きさ 0 のものは DDB が来ない。待たせずに配る (来ないまま諦めると、受け側は無いものと見なす)
+        for (const [moduleId, held] of component.building) {
+            if (held.builder.complete)
+                this.finish(component, moduleId, held);
+        }
+    }
+    /** 今の DII の一覧を配る。**諦めたモジュールは載せない** */
+    sendList(component) {
+        const dii = component.dii;
+        if (dii === null)
+            return;
+        this.send({
+            type: "moduleListUpdated",
+            componentId: component.componentId,
+            modules: dii.modules
+                .filter((module) => !component.abandoned.has(module.moduleId))
+                .map((module) => ({
+                id: module.moduleId,
+                version: module.moduleVersion,
+                size: module.moduleSize,
+            })),
+            dataEventId: component.dataEventId,
+            ...(dii.returnToEntry === null
+                ? {}
+                : { returnToEntryFlag: dii.returnToEntry }),
+        });
+    }
+    /**
+     * **来ないモジュールを諦める** (`GIVE_UP_ROUNDS`)。待っている受け側 (`Resources` の `wait`) は、
+     * DII に無いモジュールを「もう来ない」と決める (`gone`) ので、諦めたものを除いた一覧を配り直して
+     * 待ちを終わらせる。前の DII で配り終えたバージョンのままのもの (受け側が持っている) は一覧から外さず、
+     * 組み立てるのをやめるだけ。次に DII のバージョンが変われば、また待つ
+     */
+    giveUp(component) {
+        const limit = component.size * GIVE_UP_ROUNDS;
+        let changed = false;
+        for (const [moduleId, held] of component.building) {
+            if (held.quietDiis < GIVE_UP_ROUNDS || held.quietBytes < limit)
+                continue;
+            component.building.delete(moduleId);
+            if (component.done.get(moduleId) ===
+                doneMark(component, held.module.moduleVersion))
+                continue;
+            component.abandoned.add(moduleId);
+            changed = true;
+        }
+        if (changed)
+            this.sendList(component);
+    }
+    onDdb(component, section) {
+        const ddb = parseDdb(section);
+        if (ddb === null)
+            return;
+        for (const waiting of component.building.values())
+            waiting.quietBytes += ddb.block.length;
+        const held = component.building.get(ddb.moduleId);
+        // バージョンが食い違うブロックを混ぜると壊れたファイルができる
+        if (held === undefined || held.builder.moduleVersion !== ddb.moduleVersion)
+            return;
+        const before = held.builder.blocks;
+        const complete = held.builder.add(ddb.blockNumber, ddb.block);
+        if (held.builder.blocks > before) {
+            held.quietDiis = 0;
+            held.quietBytes = 0;
+        }
+        if (complete)
+            this.finish(component, ddb.moduleId, held);
+    }
+    /** 揃ったモジュールを配る */
+    finish(component, moduleId, held) {
+        // 次の DII が来るまで組み立て直さない
+        component.building.delete(moduleId);
+        /*
+         * **同じものを配り直さない。** カルーセルは回り続けるので、バージョンが上がって
+         * いなくても同じモジュールが何度も揃う。そのたびに配ると、受け側は
+         * 中身の変わらない画面を組み直し続ける
+         */
+        const version = held.builder.moduleVersion;
+        const mark = doneMark(component, version);
+        if (component.done.get(moduleId) === mark)
+            return;
+        component.done.set(moduleId, mark);
+        // 大きさ 0 は伸ばしようが無い。ファイルの無いモジュールとして配り、待っている受け側を終わらせる
+        const empty = held.module.moduleSize === 0;
+        const data = empty
+            ? held.builder.data
+            : inflate(held.builder.data, held.module.compression);
+        if (data === null)
+            return;
+        const files = moduleFiles(data, held.module.contentType);
+        if (files.length === 0 && !empty)
+            return;
+        this.send({
+            type: "moduleDownloaded",
+            componentId: component.componentId,
+            moduleId,
+            files,
+            version,
+            dataEventId: component.dataEventId,
+        });
+    }
+}
+/**
+ * 揃ったモジュールをファイルに分ける。
+ *
+ * **多くは `multipart/mixed`** で、1つのモジュールに BML と画像がまとめて
+ * 入っている。Type 記述子が無いときも中身は multipart なので、同じ扱いにする。
+ */
+export function moduleFiles(data, contentType) {
+    const declared = contentType === null ? null : parseMediaType(contentType);
+    if (declared !== null &&
+        !(declared.type === "multipart" && declared.subtype === "mixed")) {
+        return [
+            {
+                contentLocation: null,
+                contentType: declared,
+                dataBase64: base64(data),
+            },
+        ];
+    }
+    const entity = readEntity(data);
+    if (entity?.parts == null)
+        return [];
+    const files = [];
+    for (const part of entity.parts) {
+        const location = part.headers.find((header) => header.name === "content-location");
+        const type = part.headers.find((header) => header.name === "content-type");
+        // どちらも必ず入っている。欠けているものは置き場所も読み方も分からない
+        if (location === undefined || type === undefined)
+            continue;
+        const mediaType = parseMediaType(type.value);
+        if (mediaType === null)
+            continue;
+        files.push({
+            contentLocation: location.value,
+            contentType: mediaType,
+            dataBase64: base64(part.body),
+        });
+    }
+    return files;
+}
+function base64(data) {
+    return Buffer.from(data).toString("base64");
+}
+/** zlib で縮めてあれば伸ばす。伸ばせなければ諦めて null */
+export function inflate(data, compression) {
+    if (compression === null)
+        return data;
+    if (compression.type !== COMPRESSION_ZLIB)
+        return null;
+    try {
+        // 伸ばした大きさにも上限を置く。小さな DDB から何 GB にも伸びるものを作れる
+        return inflateSync(data, { maxOutputLength: MAX_MODULE_SIZE });
+    }
+    catch {
+        return null;
+    }
+}

package/dist/bytes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * バイト列の細かい道具。**中身の意味は持たない。** 繋ぐ・読むのはここで済ませる (別名で書き直さない)
+ */
+/** バイト列を新しい1本に繋ぐ (いつも写す。`Blob` などへ渡せる `ArrayBuffer` の上に作る) */
+export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array<ArrayBuffer>;
+/**
+ * バイト列を1本に繋ぐ。
+ *
+ * **1本しかないときは写しません。** 分割された記述子を繋ぎ直すところ
+ * ([eit.ts](eit.ts)) では、繋ぐ必要のないほうが多数です
+ */
+export declare function joinBytes(parts: readonly Uint8Array[]): Uint8Array;
+/** 大きい桁が先の 16 ビット */
+export declare function u16(data: Uint8Array, at: number): number;
+/** 大きい桁が先の 24 ビット */
+export declare function u24(data: Uint8Array, at: number): number;
+/** 大きい桁が先の 32 ビット (符号なし) */
+export declare function u32(data: Uint8Array, at: number): number;
+/** `length` バイトをそのまま1字ずつの文字列に (MP4 の箱の種別・PNG の塊の名前・言語の符号) */
+export declare function ascii(data: Uint8Array, at: number, length: number): string;

package/dist/bytes.js

@@ -0,0 +1,45 @@
+/**
+ * バイト列の細かい道具。**中身の意味は持たない。** 繋ぐ・読むのはここで済ませる (別名で書き直さない)
+ */
+/** バイト列を新しい1本に繋ぐ (いつも写す。`Blob` などへ渡せる `ArrayBuffer` の上に作る) */
+export function concatBytes(parts) {
+    let total = 0;
+    for (const part of parts)
+        total += part.length;
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+}
+/**
+ * バイト列を1本に繋ぐ。
+ *
+ * **1本しかないときは写しません。** 分割された記述子を繋ぎ直すところ
+ * ([eit.ts](eit.ts)) では、繋ぐ必要のないほうが多数です
+ */
+export function joinBytes(parts) {
+    return parts.length === 1 ? parts[0] : concatBytes(parts);
+}
+/** 大きい桁が先の 16 ビット */
+export function u16(data, at) {
+    return (data[at] << 8) | data[at + 1];
+}
+/** 大きい桁が先の 24 ビット */
+export function u24(data, at) {
+    return (data[at] << 16) | u16(data, at + 1);
+}
+/** 大きい桁が先の 32 ビット (符号なし) */
+export function u32(data, at) {
+    return (((data[at] << 24) |
+        (data[at + 1] << 16) |
+        (data[at + 2] << 8) |
+        data[at + 3]) >>>
+        0);
+}
+/** `length` バイトをそのまま1字ずつの文字列に (MP4 の箱の種別・PNG の塊の名前・言語の符号) */
+export function ascii(data, at, length) {
+    return String.fromCharCode(...data.subarray(at, at + length));
+}