@danything/arib 0.0.0-stage → 0.1.0

package/dist/psi.d.ts

@@ -0,0 +1,169 @@
+/**
+ * TS の土台 (パケットの切り出し・セクションの組み立て・PAT/PMT) と、局の一覧。
+ * 局の一覧はチャンネルスキャンで「この物理チャンネルに何が入っているか」を知るために使い、
+ * 読むのは NIT と SDT の2つ。
+ *
+ * - NIT (PID 0x0010) … ネットワークID と、地上波ならリモコン番号
+ * - SDT (PID 0x0011) … その TS に入っているサービスのIDと種別
+ *
+ * 局名も SDT から読む。ARIB の文字符号は独自だが、番組表を自分で集めるなら
+ * どのみち要るので [aribtext.ts](aribtext.ts) に寄せてある。
+ */
+export declare const PACKET = 188;
+export declare const SYNC = 71;
+/** TS パケットの PID */
+export declare function packetPid(packet: Uint8Array): number;
+/** PAT。どの PID に PMT があるかを持つ。**入口はいつもここ** */
+export declare const PID_PAT = 0;
+export declare const PID_SDT = 17;
+export declare const TABLE_PAT = 0;
+export declare const TABLE_PMT = 2;
+export declare const TABLE_SDT_ACTUAL = 66;
+/**
+ * セクション本体に CRC32 を付けて仕上げる。`section_length` も実長に直す。
+ *
+ * **書く側が2つある。** PAT を書き直して流す `service-filter.ts` と、
+ * 偽の放送を組み立てる `synth.ts`。長さの直し方を間違えると読む側が黙って
+ * 捨てるだけなので、1箇所に置く。
+ */
+export declare function withCrc(body: number[]): Uint8Array;
+export interface Service {
+    serviceId: number;
+    serviceType: number;
+    /** 局名。SDT からしか取れないので、NIT 由来のものは空 */
+    name: string;
+}
+export interface TransportInfo {
+    transportStreamId: number;
+    originalNetworkId: number;
+    services: Service[];
+}
+export interface NetworkInfo {
+    networkId: number;
+    remoteControlKeyId: number | null;
+    transportStreams: TransportInfo[];
+}
+/**
+ * PSI セクションを組み立てる。
+ *
+ * セクションは TS パケットをまたいで運ばれ、パケットの切れ目とは無関係な
+ * 位置で終わる。payload_unit_start_indicator と pointer_field を見て
+ * 頭を合わせ、section_length ぶん溜まったら1本として吐く。
+ */
+export declare class SectionAssembler {
+    private readonly pid;
+    private readonly crc;
+    private buffer;
+    /**
+     * @param pid 読むPID
+     * @param crc CRC の見方。
+     *   `always` … 末尾4バイトを CRC32 とみなして必ず確かめる (PSI はこちら)
+     *   `syntax` … `section_syntax_indicator` が立っているときだけ確かめる。
+     *     DSM-CC は立っていないと末尾が CRC ではなく Checksum なので、
+     *     いつも確かめると**全部捨ててしまう**
+     */
+    constructor(pid: number, crc?: "always" | "syntax");
+    /**
+     * パケットを1つ食わせる。組み上がったセクションを返す。
+     *
+     * 返りは**読むだけ**にすること。何も組み上がらないとき (ほとんどのパケット) は
+     * 使い回しの空配列を返す — 関係ないパケットのたびに配列を作っていた
+     */
+    feed(packet: Uint8Array): readonly Uint8Array[];
+    private append;
+    private flush;
+}
+/** `from` 以降 `until` の手前までで、188 間隔に 0x47 が続くところを探す。無ければ -1 (`seek.ts` も使う) */
+export declare function findSync(data: Uint8Array, from?: number, until?: number): number;
+/**
+ * 任意の長さで届くバイト列を 188 バイトのパケットに切り分ける。
+ *
+ * 頭が必ずパケットの先頭とは限らず、電波が弱いと途中で数バイト落ちる。
+ * ずれたままだと**以降ずっと1パケットも読めなくなる**ので、頭が 0x47 でなければ
+ * 取り直す。普段は先頭が 0x47 なので、探しに行くのはずれたときだけ。
+ *
+ * **出すパケットは渡された塊の上の窓** (写しではない。写すと録画の処理の 1/3 を食う)。
+ * 塊の入れ物を使い回す呼び出し側がある
+ * (`server/recorded-bml.ts`) ので、**次の `feed` より後まで持つなら写すこと**。
+ * いまのパーサ (`SectionAssembler`・`PesDemuxer`) は溜めるときに写している
+ */
+export declare class PacketStream {
+    private rest;
+    feed(chunk: Uint8Array): Generator<Uint8Array>;
+}
+/**
+ * PAT から1つの局の PMT を追う。`serviceId` を渡さなければ PAT の最初の局
+ * (1局に絞った TS を食わせるところ)。PAT で PMT の PID が替われば組み立て直す
+ */
+export declare class PmtTracker {
+    private readonly serviceId?;
+    private readonly pat;
+    private pmt;
+    /** 追っている PMT の PID。PAT を読むまでは null。替わったかは呼ぶ前後で比べる */
+    pid: number | null;
+    constructor(serviceId?: number | undefined);
+    /** パケットを1つ (`pid` はその PID)。組み上がった PMT のセクションを返す */
+    feed(packet: Uint8Array, pid: number): readonly Uint8Array[];
+}
+/** 記述子の並びを (tag, 中身) に切り分ける */
+export declare function descriptors(data: Uint8Array): Generator<[number, Uint8Array]>;
+/** デジタルコピー制御記述子。EIT の番組ごとと PMT に入る */
+export declare const DESC_DIGITAL_COPY_CONTROL = 193;
+/**
+ * デジタルコピー制御記述子の中身 (タグと長さを除いたもの) から、**コピー禁止か**を読む。
+ *
+ * 先頭2ビットの digital_recording_control_data が 11 なら禁止
+ * (00 コピー可、01 事業者定義、10 1世代のみ)。禁止の番組は録らない
+ * ([data.md](https://github.com/danything/denpa/blob/main/docs/data.md)「コピー禁止の番組」)
+ */
+export declare function isCopyNever(data: Uint8Array): boolean;
+/**
+ * PMT の**番組ぜんたいに掛かる記述子** (program_info)。CA (ECM の PID) はここにも入る
+ */
+export declare function pmtProgramInfo(section: Uint8Array): Uint8Array;
+/**
+ * PMT の ES の並びを `[stream_type, PID, 記述子]` で返す。
+ *
+ * **`stream_type` では物を見分けられません。** データ放送も AIT もロゴも同じ
+ * DSM-CC セクション (0x0D) を名乗るので、見分けるのは記述子のほう
+ * (component_tag や application_signalling) です。だからここは**素通しで並べる
+ * だけ**にして、選り分けは呼ぶ側に置いてあります。
+ */
+export declare function pmtStreams(section: Uint8Array): Generator<[number, number, Uint8Array]>;
+/** PAT から `サービスID → PMT の PID`。サービス0 は NIT なので飛ばす */
+export declare function parsePat(section: Uint8Array): Map<number, number>;
+/**
+ * SDT のサービスの並びを (service_id, 記述子の並び) に切り分ける。
+ *
+ * **読む側が2つある。** 局名 (`parseSdt`) とロゴの対応 (`ts/logo.ts`) で、
+ * 欲しい記述子が違うだけで歩き方は同じ。並びの読み方をここ1箇所に置く。
+ */
+export declare function sdtServices(section: Uint8Array): Generator<[number, Uint8Array]>;
+/** SDT からサービスの一覧を読む。自分の TS のものだけ */
+export declare function parseSdt(section: Uint8Array): TransportInfo | null;
+/** NIT からネットワークIDとリモコン番号、他の TS の顔ぶれを読む */
+export declare function parseNit(section: Uint8Array): NetworkInfo | null;
+export interface FoundService extends Service {
+    networkId: number;
+    transportStreamId: number;
+    remoteControlKeyId: number | null;
+}
+/**
+ * 流れてくる TS を食べて、NIT と SDT が揃うまで待つ。
+ *
+ * Mirakurun のスキャンと同じで、**両方**揃って初めてそのチャンネルを
+ * 「受信できた」とみなす。SDT だけ取れても、どのネットワークのものか
+ * 分からないと設定に書けない。
+ */
+export declare class ServiceReader {
+    private readonly nit;
+    private readonly sdt;
+    private readonly packets;
+    network: NetworkInfo | null;
+    transport: TransportInfo | null;
+    get complete(): boolean;
+    /** 任意の長さのバイト列を食わせる。揃ったら true */
+    feed(chunk: Uint8Array): boolean;
+    /** 録るに値するサービスだけ。リモコン番号は NIT のものを配る */
+    services(): FoundService[];
+}

package/dist/psi.js

@@ -0,0 +1,497 @@
+/**
+ * TS の土台 (パケットの切り出し・セクションの組み立て・PAT/PMT) と、局の一覧。
+ * 局の一覧はチャンネルスキャンで「この物理チャンネルに何が入っているか」を知るために使い、
+ * 読むのは NIT と SDT の2つ。
+ *
+ * - NIT (PID 0x0010) … ネットワークID と、地上波ならリモコン番号
+ * - SDT (PID 0x0011) … その TS に入っているサービスのIDと種別
+ *
+ * 局名も SDT から読む。ARIB の文字符号は独自だが、番組表を自分で集めるなら
+ * どのみち要るので [aribtext.ts](aribtext.ts) に寄せてある。
+ */
+import { decodeAribText } from "./aribtext.js";
+import { concatBytes, u16 } from "./bytes.js";
+export const PACKET = 188;
+export const SYNC = 0x47;
+/** TS パケットの PID */
+export function packetPid(packet) {
+    return ((packet[1] & 0x1f) << 8) | packet[2];
+}
+/** PAT。どの PID に PMT があるかを持つ。**入口はいつもここ** */
+export const PID_PAT = 0x0000;
+const PID_NIT = 0x0010;
+export const PID_SDT = 0x0011;
+export const TABLE_PAT = 0x00;
+export const TABLE_PMT = 0x02;
+const TABLE_NIT_ACTUAL = 0x40;
+export const TABLE_SDT_ACTUAL = 0x42;
+const DESC_SERVICE_LIST = 0x41;
+const DESC_SERVICE = 0x48;
+const DESC_TS_INFORMATION = 0xcd;
+/**
+ * スキャンで残すサービス種別。Mirakurun のスキャンが通しているものと同じで、
+ * ラジオ (0x02) とデータ (0xc0) も入る。映像の無いものを番組表に並べないのは
+ * 取り込むほう (epg.ts の DIGITAL_TV)
+ */
+const SERVICE_TYPES = new Set([0x01, 0x02, 0xa1, 0xa4, 0xa5, 0xad, 0xc0]);
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let crc = i << 24;
+        for (let bit = 0; bit < 8; bit++) {
+            crc =
+                crc & 0x80000000 ? ((crc << 1) ^ 0x04c11db7) >>> 0 : (crc << 1) >>> 0;
+        }
+        table[i] = crc >>> 0;
+    }
+    return table;
+})();
+/** MPEG-2 の CRC32。セクション末尾の4バイトを含めて回すと 0 になる */
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data) {
+        crc =
+            (((crc << 8) >>> 0) ^ CRC32_TABLE[((crc >>> 24) ^ byte) & 0xff]) >>> 0;
+    }
+    return crc >>> 0;
+}
+/**
+ * セクション本体に CRC32 を付けて仕上げる。`section_length` も実長に直す。
+ *
+ * **書く側が2つある。** PAT を書き直して流す `service-filter.ts` と、
+ * 偽の放送を組み立てる `synth.ts`。長さの直し方を間違えると読む側が黙って
+ * 捨てるだけなので、1箇所に置く。
+ */
+export function withCrc(body) {
+    const section = Uint8Array.from(body);
+    const length = section.length - 3 + 4;
+    section[1] = 0xb0 | ((length >> 8) & 0x0f);
+    section[2] = length & 0xff;
+    const out = new Uint8Array(section.length + 4);
+    out.set(section);
+    new DataView(out.buffer).setUint32(section.length, crc32(section));
+    return out;
+}
+/** 何も組み上がらなかったときの返り。使い回すので凍らせてある */
+const NONE = Object.freeze([]);
+/**
+ * PSI セクションを組み立てる。
+ *
+ * セクションは TS パケットをまたいで運ばれ、パケットの切れ目とは無関係な
+ * 位置で終わる。payload_unit_start_indicator と pointer_field を見て
+ * 頭を合わせ、section_length ぶん溜まったら1本として吐く。
+ */
+export class SectionAssembler {
+    pid;
+    crc;
+    buffer = new Uint8Array(0);
+    /**
+     * @param pid 読むPID
+     * @param crc CRC の見方。
+     *   `always` … 末尾4バイトを CRC32 とみなして必ず確かめる (PSI はこちら)
+     *   `syntax` … `section_syntax_indicator` が立っているときだけ確かめる。
+     *     DSM-CC は立っていないと末尾が CRC ではなく Checksum なので、
+     *     いつも確かめると**全部捨ててしまう**
+     */
+    constructor(pid, crc = "always") {
+        this.pid = pid;
+        this.crc = crc;
+    }
+    /**
+     * パケットを1つ食わせる。組み上がったセクションを返す。
+     *
+     * 返りは**読むだけ**にすること。何も組み上がらないとき (ほとんどのパケット) は
+     * 使い回しの空配列を返す — 関係ないパケットのたびに配列を作っていた
+     */
+    feed(packet) {
+        // トランスポートエラーが立っているものは信用しない
+        if (packet[0] !== SYNC ||
+            packetPid(packet) !== this.pid ||
+            packet[1] & 0x80)
+            return NONE;
+        const adaptation = (packet[3] >> 4) & 0x03;
+        if (adaptation === 0 || adaptation === 2)
+            return NONE;
+        let offset = 4;
+        if (adaptation === 3)
+            offset += 1 + packet[4];
+        if (offset >= PACKET)
+            return NONE;
+        const payload = packet.subarray(offset);
+        if (packet[1] & 0x40) {
+            const pointer = payload[0];
+            if (1 + pointer > payload.length)
+                return NONE;
+            // pointer_field の手前は前のセクションの続き
+            this.append(payload.subarray(1, 1 + pointer));
+            const done = this.flush();
+            // 写す。パケットは届いた塊の上の窓で、塊は使い回される (PacketStream)
+            this.buffer = payload.slice(1 + pointer);
+            const next = this.flush();
+            if (done.length === 0)
+                return next;
+            return next.length === 0 ? done : [...done, ...next];
+        }
+        this.append(payload);
+        return this.flush();
+    }
+    append(data) {
+        if (this.buffer.length > 0)
+            this.buffer = concatBytes([this.buffer, data]);
+    }
+    flush() {
+        let sections = null;
+        for (;;) {
+            if (this.buffer.length < 3)
+                return sections ?? NONE;
+            // 詰め物。ここから先にセクションは無い
+            if (this.buffer[0] === 0xff) {
+                this.buffer = new Uint8Array(0);
+                return sections ?? NONE;
+            }
+            const length = 3 + (u16(this.buffer, 1) & 0x0fff);
+            if (this.buffer.length < length)
+                return sections ?? NONE;
+            const section = this.buffer.slice(0, length);
+            this.buffer = this.buffer.slice(length);
+            // 壊れたセクションを読むと嘘の局が並ぶので、CRC を通ったものだけ使う
+            const syntax = (section[1] & 0x80) !== 0;
+            if ((this.crc === "syntax" && !syntax) || crc32(section) === 0) {
+                sections ??= [];
+                sections.push(section);
+            }
+        }
+    }
+}
+/**
+ * 同期が取れているとみなすのに必要な連続パケット数。
+ * 1つだけでは中身のたまたまの 0x47 を頭と誤認する
+ */
+const CONFIRM = 3;
+/** `from` 以降 `until` の手前までで、188 間隔に 0x47 が続くところを探す。無ければ -1 (`seek.ts` も使う) */
+export function findSync(data, from = 0, until = data.length) {
+    for (let at = from; at < until && at + PACKET * (CONFIRM - 1) < data.length; at++) {
+        let i = 0;
+        while (i < CONFIRM && data[at + i * PACKET] === SYNC)
+            i++;
+        if (i === CONFIRM)
+            return at;
+    }
+    return -1;
+}
+/**
+ * 任意の長さで届くバイト列を 188 バイトのパケットに切り分ける。
+ *
+ * 頭が必ずパケットの先頭とは限らず、電波が弱いと途中で数バイト落ちる。
+ * ずれたままだと**以降ずっと1パケットも読めなくなる**ので、頭が 0x47 でなければ
+ * 取り直す。普段は先頭が 0x47 なので、探しに行くのはずれたときだけ。
+ *
+ * **出すパケットは渡された塊の上の窓** (写しではない。写すと録画の処理の 1/3 を食う)。
+ * 塊の入れ物を使い回す呼び出し側がある
+ * (`server/recorded-bml.ts`) ので、**次の `feed` より後まで持つなら写すこと**。
+ * いまのパーサ (`SectionAssembler`・`PesDemuxer`) は溜めるときに写している
+ */
+export class PacketStream {
+    rest = new Uint8Array(0);
+    *feed(chunk) {
+        /*
+         * 前の残り (`rest`) と塊を繋いだ並びの上を歩く。位置 `at` はその並びでの位置。
+         * 繋ぐのは**残りに頭があるパケットを読むのに要るぶんだけ** (頭を探すのに
+         * 3パケットぶん先まで見る)
+         */
+        const split = this.rest.length;
+        const total = split + chunk.length;
+        let at = 0;
+        let lost = false;
+        if (split > 0) {
+            const head = new Uint8Array(split + Math.min(chunk.length, PACKET * CONFIRM));
+            head.set(this.rest);
+            head.set(chunk.subarray(0, head.length - split), split);
+            while (at < split && at + PACKET <= total) {
+                if (head[at] !== SYNC) {
+                    const found = findSync(head, at, split);
+                    // 残りの中には無い。塊のほうを探す
+                    if (found < 0) {
+                        lost = true;
+                        break;
+                    }
+                    at = found;
+                }
+                yield head.subarray(at, at + PACKET);
+                at += PACKET;
+            }
+        }
+        let offset = at - split;
+        if (lost) {
+            const found = findSync(chunk);
+            if (found >= 0) {
+                offset = found;
+                lost = false;
+            }
+        }
+        if (!lost) {
+            while (offset + PACKET <= chunk.length) {
+                if (chunk[offset] !== SYNC) {
+                    const found = findSync(chunk, offset);
+                    if (found < 0)
+                        break;
+                    offset = found;
+                    if (offset + PACKET > chunk.length)
+                        break;
+                }
+                yield chunk.subarray(offset, offset + PACKET);
+                offset += PACKET;
+            }
+            at = split + offset;
+        }
+        // 同期が取れないまま溜め込まないよう、頭を探せるぶんだけ残す
+        const from = Math.max(at, total - PACKET * CONFIRM);
+        if (from >= split) {
+            this.rest = chunk.slice(from - split);
+        }
+        else {
+            // 塊が短くて、前の残りにまだ食い込んでいる
+            const rest = new Uint8Array(total - from);
+            rest.set(this.rest.subarray(from));
+            rest.set(chunk, split - from);
+            this.rest = rest;
+        }
+    }
+}
+/**
+ * PAT から1つの局の PMT を追う。`serviceId` を渡さなければ PAT の最初の局
+ * (1局に絞った TS を食わせるところ)。PAT で PMT の PID が替われば組み立て直す
+ */
+export class PmtTracker {
+    serviceId;
+    pat = new SectionAssembler(PID_PAT);
+    pmt = null;
+    /** 追っている PMT の PID。PAT を読むまでは null。替わったかは呼ぶ前後で比べる */
+    pid = null;
+    constructor(serviceId) {
+        this.serviceId = serviceId;
+    }
+    /** パケットを1つ (`pid` はその PID)。組み上がった PMT のセクションを返す */
+    feed(packet, pid) {
+        if (pid === PID_PAT) {
+            for (const section of this.pat.feed(packet)) {
+                const programs = parsePat(section);
+                const next = this.serviceId === undefined
+                    ? programs.values().next().value
+                    : programs.get(this.serviceId);
+                if (next === undefined || next === this.pid)
+                    continue;
+                this.pid = next;
+                this.pmt = new SectionAssembler(next);
+            }
+        }
+        return pid === this.pid ? this.pmt.feed(packet) : NONE;
+    }
+}
+/** 記述子の並びを (tag, 中身) に切り分ける */
+export function* descriptors(data) {
+    let at = 0;
+    while (at + 2 <= data.length) {
+        const tag = data[at];
+        const length = data[at + 1];
+        const body = data.subarray(at + 2, at + 2 + length);
+        if (body.length < length)
+            return;
+        yield [tag, body];
+        at += 2 + length;
+    }
+}
+/** デジタルコピー制御記述子。EIT の番組ごとと PMT に入る */
+export const DESC_DIGITAL_COPY_CONTROL = 0xc1;
+/**
+ * デジタルコピー制御記述子の中身 (タグと長さを除いたもの) から、**コピー禁止か**を読む。
+ *
+ * 先頭2ビットの digital_recording_control_data が 11 なら禁止
+ * (00 コピー可、01 事業者定義、10 1世代のみ)。禁止の番組は録らない
+ * ([data.md](https://github.com/danything/denpa/blob/main/docs/data.md)「コピー禁止の番組」)
+ */
+export function isCopyNever(data) {
+    return data.length >= 1 && data[0] >> 6 === 0b11;
+}
+/**
+ * PMT の**番組ぜんたいに掛かる記述子** (program_info)。CA (ECM の PID) はここにも入る
+ */
+export function pmtProgramInfo(section) {
+    if (section[0] !== TABLE_PMT || section.length < 16)
+        return new Uint8Array(0);
+    const length = u16(section, 10) & 0x0fff;
+    return section.subarray(12, 12 + length);
+}
+/**
+ * PMT の ES の並びを `[stream_type, PID, 記述子]` で返す。
+ *
+ * **`stream_type` では物を見分けられません。** データ放送も AIT もロゴも同じ
+ * DSM-CC セクション (0x0D) を名乗るので、見分けるのは記述子のほう
+ * (component_tag や application_signalling) です。だからここは**素通しで並べる
+ * だけ**にして、選り分けは呼ぶ側に置いてあります。
+ */
+export function* pmtStreams(section) {
+    if (section[0] !== TABLE_PMT || section.length < 16)
+        return;
+    const programInfoLength = u16(section, 10) & 0x0fff;
+    let at = 12 + programInfoLength;
+    const end = section.length - 4;
+    while (at + 5 <= end) {
+        const pid = u16(section, at + 1) & 0x1fff;
+        const infoLength = u16(section, at + 3) & 0x0fff;
+        yield [section[at], pid, section.subarray(at + 5, at + 5 + infoLength)];
+        at += 5 + infoLength;
+    }
+}
+/** PAT から `サービスID → PMT の PID`。サービス0 は NIT なので飛ばす */
+export function parsePat(section) {
+    const programs = new Map();
+    if (section[0] !== TABLE_PAT)
+        return programs;
+    const end = section.length - 4;
+    for (let at = 8; at + 4 <= end; at += 4) {
+        const serviceId = u16(section, at);
+        if (serviceId === 0)
+            continue;
+        programs.set(serviceId, u16(section, at + 2) & 0x1fff);
+    }
+    return programs;
+}
+/**
+ * SDT のサービスの並びを (service_id, 記述子の並び) に切り分ける。
+ *
+ * **読む側が2つある。** 局名 (`parseSdt`) とロゴの対応 (`ts/logo.ts`) で、
+ * 欲しい記述子が違うだけで歩き方は同じ。並びの読み方をここ1箇所に置く。
+ */
+export function* sdtServices(section) {
+    let at = 11;
+    const end = section.length - 4;
+    while (at + 5 <= end) {
+        const serviceId = u16(section, at);
+        const loop = u16(section, at + 3) & 0x0fff;
+        yield [serviceId, section.subarray(at + 5, at + 5 + loop)];
+        at += 5 + loop;
+    }
+}
+/** SDT からサービスの一覧を読む。自分の TS のものだけ */
+export function parseSdt(section) {
+    if (section[0] !== TABLE_SDT_ACTUAL)
+        return null;
+    const services = [];
+    for (const [serviceId, body] of sdtServices(section)) {
+        for (const [tag, descriptor] of descriptors(body)) {
+            if (tag === DESC_SERVICE && descriptor.length > 0) {
+                /*
+                 * service_descriptor は 種別 → 事業者名 → サービス名 の順。
+                 * 事業者名 (「東京メトロポリタンテレビジョン」) は要らないので飛ばし、
+                 * その先のサービス名 (「TOKYO MX1」) を取る
+                 */
+                const providerLength = descriptor[1] ?? 0;
+                const nameAt = 2 + providerLength;
+                const nameLength = descriptor[nameAt] ?? 0;
+                services.push({
+                    serviceId,
+                    serviceType: descriptor[0],
+                    name: decodeAribText(descriptor.subarray(nameAt + 1, nameAt + 1 + nameLength)),
+                });
+                break;
+            }
+        }
+    }
+    return {
+        transportStreamId: u16(section, 3),
+        originalNetworkId: u16(section, 8),
+        services,
+    };
+}
+/** NIT からネットワークIDとリモコン番号、他の TS の顔ぶれを読む */
+export function parseNit(section) {
+    if (section[0] !== TABLE_NIT_ACTUAL)
+        return null;
+    const networkLength = u16(section, 8) & 0x0fff;
+    let at = 10 + networkLength;
+    if (at + 2 > section.length)
+        return null;
+    at += 2; // transport_stream_loop_length
+    let remoteControlKeyId = null;
+    const transportStreams = [];
+    const end = section.length - 4;
+    while (at + 6 <= end) {
+        const transportStreamId = u16(section, at);
+        const originalNetworkId = u16(section, at + 2);
+        const loop = u16(section, at + 4) & 0x0fff;
+        const body = section.subarray(at + 6, at + 6 + loop);
+        at += 6 + loop;
+        const services = [];
+        for (const [tag, descriptor] of descriptors(body)) {
+            if (tag === DESC_TS_INFORMATION &&
+                descriptor.length > 0 &&
+                remoteControlKeyId === null) {
+                remoteControlKeyId = descriptor[0];
+            }
+            else if (tag === DESC_SERVICE_LIST) {
+                for (let i = 0; i + 3 <= descriptor.length; i += 3) {
+                    services.push({
+                        serviceId: u16(descriptor, i),
+                        serviceType: descriptor[i + 2],
+                        name: "",
+                    });
+                }
+            }
+        }
+        transportStreams.push({ transportStreamId, originalNetworkId, services });
+    }
+    return {
+        networkId: u16(section, 3),
+        remoteControlKeyId,
+        transportStreams,
+    };
+}
+/**
+ * 流れてくる TS を食べて、NIT と SDT が揃うまで待つ。
+ *
+ * Mirakurun のスキャンと同じで、**両方**揃って初めてそのチャンネルを
+ * 「受信できた」とみなす。SDT だけ取れても、どのネットワークのものか
+ * 分からないと設定に書けない。
+ */
+export class ServiceReader {
+    nit = new SectionAssembler(PID_NIT);
+    sdt = new SectionAssembler(PID_SDT);
+    packets = new PacketStream();
+    network = null;
+    transport = null;
+    get complete() {
+        return this.network !== null && this.transport !== null;
+    }
+    /** 任意の長さのバイト列を食わせる。揃ったら true */
+    feed(chunk) {
+        for (const packet of this.packets.feed(chunk)) {
+            if (this.network === null) {
+                for (const section of this.nit.feed(packet)) {
+                    this.network = parseNit(section) ?? this.network;
+                }
+            }
+            if (this.transport === null) {
+                for (const section of this.sdt.feed(packet)) {
+                    this.transport = parseSdt(section) ?? this.transport;
+                }
+            }
+        }
+        return this.complete;
+    }
+    /** 録るに値するサービスだけ。リモコン番号は NIT のものを配る */
+    services() {
+        if (this.network === null || this.transport === null)
+            return [];
+        const { networkId, remoteControlKeyId } = this.network;
+        const { transportStreamId } = this.transport;
+        return this.transport.services
+            .filter((service) => SERVICE_TYPES.has(service.serviceType))
+            .map((service) => ({
+            ...service,
+            networkId,
+            transportStreamId,
+            remoteControlKeyId,
+        }));
+    }
+}