@danything/arib 2.0.0 → 2.2.0

package/dist/mmtp.js

@@ -0,0 +1,232 @@
+/**
+ * MMTP のパケット (ISO/IEC 23008-1、ARIB STD-B60) を読み、信号メッセージを組み立てる。
+ *
+ * MMTP のパケットは UDP 1 つに 1 つ入っている (`tlv-ip.ts`)。中身は 2 種類で、
+ * 映像・音声・字幕を運ぶ MPU (payload_type 0) と、局の中身の一覧や番組表を運ぶ信号メッセージ (2)。
+ * どちらかは packet_id ごとに決まっている。
+ *
+ * **4K の放送では映像と音声がスクランブルされ、信号はされていない** (実機のケーブルの BS4K で確かめた)。
+ * スクランブルの印はヘッダー拡張にあり (ARIB STD-B61)、MPU のペイロードヘッダー (8 バイト) までは読める。
+ * 復号はエージェントの仕事 (まだ扱わない)。
+ */
+import { concatBytes, u16, u32 } from "./bytes.js";
+export const PAYLOAD_MPU = 0x00;
+export const PAYLOAD_SIGNALING = 0x02;
+/** 種類がいくつも入るヘッダー拡張 (B61)。中に種類と長さの組が並ぶ */
+const EXTENSION_MULTI = 0x0000;
+/** ヘッダー拡張の中の、スクランブルの印の種類 */
+const EXTENSION_SCRAMBLE = 0x0001;
+const SCRAMBLING = {
+    0: "none",
+    2: "even",
+    3: "odd",
+};
+/** MMTP のパケットを 1 つ読む。短すぎれば null */
+export function parseMmtp(data) {
+    if (data.length < 12)
+        return null;
+    const flags = data[0];
+    let at = 12;
+    // packet_counter_flag
+    if (flags & 0x20)
+        at += 4;
+    let scrambling = null;
+    // extension_flag
+    if (flags & 0x02) {
+        if (at + 4 > data.length)
+            return null;
+        const type = u16(data, at) & 0x7fff;
+        const length = u16(data, at + 2);
+        const body = data.subarray(at + 4, at + 4 + length);
+        if (body.length < length)
+            return null;
+        if (type === EXTENSION_MULTI)
+            scrambling = scramblingOf(body);
+        at += 4 + length;
+    }
+    return {
+        rap: (flags & 0x01) !== 0,
+        payloadType: data[1] & 0x3f,
+        packetId: u16(data, 2),
+        deliveryTimestamp: u32(data, 4),
+        sequenceNumber: u32(data, 8),
+        scrambling,
+        payload: data.subarray(at),
+    };
+}
+/** 種類がいくつも入るヘッダー拡張から、スクランブルの印を探す。種類の上位 1 ビットは「これで終わり」 */
+function scramblingOf(body) {
+    let at = 0;
+    while (at + 4 <= body.length) {
+        const type = u16(body, at);
+        const length = u16(body, at + 2);
+        if ((type & 0x7fff) === EXTENSION_SCRAMBLE && length >= 1)
+            return SCRAMBLING[body[at + 4] >> 6] ?? null;
+        at += 4 + length;
+        if (type & 0x8000)
+            break;
+    }
+    return null;
+}
+/** 分割の印 (fragmentation_indicator)。0 は分割していない、1 は先頭、2 は途中、3 は最後 */
+const WHOLE = 0;
+const FIRST = 1;
+const LAST = 3;
+export function parseMpu(payload) {
+    if (payload.length < 8)
+        return null;
+    const flags = payload[2];
+    return {
+        fragmentType: flags >> 4,
+        timed: (flags & 0x08) !== 0,
+        fragmentation: (flags >> 1) & 0x03,
+        aggregated: (flags & 0x01) !== 0,
+        fragmentCounter: payload[3],
+        mpuSequenceNumber: u32(payload, 4),
+        data: payload.subarray(8, Math.min(payload.length, 2 + u16(payload, 0))),
+    };
+}
+export const MESSAGE_PA = 0x0000;
+export const MESSAGE_M2_SECTION = 0x8000;
+export const MESSAGE_CA = 0x8001;
+export const MESSAGE_M2_SHORT_SECTION = 0x8002;
+/** PA メッセージは長さが 32 ビット、ほかの信号メッセージは 16 ビット */
+function lengthBytes(messageId) {
+    return messageId === MESSAGE_PA ? 4 : 2;
+}
+/** 信号メッセージを 1 つ読む。長さが合わなければ null */
+export function parseMessage(data) {
+    if (data.length < 3)
+        return null;
+    const messageId = u16(data, 0);
+    const width = lengthBytes(messageId);
+    const at = 3 + width;
+    if (data.length < at)
+        return null;
+    const length = width === 4 ? u32(data, 3) : u16(data, 3);
+    if (data.length < at + length)
+        return null;
+    return {
+        messageId,
+        version: data[2],
+        body: data.subarray(at, at + length),
+    };
+}
+/**
+ * 信号メッセージに入った表を返す。
+ *
+ * - PA メッセージは表の数と、表ごとの (table_id・バージョン・長さ) を先に並べ、そのあとに表を並べる。
+ *   表の頭は table_id・バージョン・長さ (16 ビット) で、MPT と PLT はこの形式
+ * - M2 セクションメッセージ・M2 短セクションメッセージ・CA メッセージは、表を 1 つだけ運ぶ。
+ *   M2 セクションは TS のセクションと同じ形式で、末尾に CRC32 が付く (確かめるのは `mmt-si.ts`)
+ */
+export function messageTables(message) {
+    const body = message.body;
+    switch (message.messageId) {
+        case MESSAGE_PA: {
+            if (body.length < 1)
+                return [];
+            const tables = [];
+            let at = 1 + body[0] * 4;
+            while (at + 4 <= body.length) {
+                const end = at + 4 + u16(body, at + 2);
+                if (end > body.length)
+                    break;
+                tables.push(body.subarray(at, end));
+                at = end;
+            }
+            return tables;
+        }
+        case MESSAGE_M2_SECTION:
+        case MESSAGE_M2_SHORT_SECTION:
+        case MESSAGE_CA:
+            return body.length > 0 ? [body] : [];
+        default:
+            return [];
+    }
+}
+/**
+ * 組み立て中のメッセージの大きさの上限。PA メッセージの表は長さが 16 ビット (64 KiB まで) で、M2 セクションは 4 KiB まで。
+ * 最後の断片が来ないまま途中の断片が続いても、溜め続けない
+ */
+const PENDING_MOST = 256 * 1024;
+/**
+ * MMTP の信号メッセージを組み立てる。**分割と集約の両方を戻す。**
+ *
+ * - 長いメッセージ (番組表の MH-EIT や大きな MPT) は、いくつもの MMTP のパケットに分割して送られる。
+ *   欠けは packet_sequence_number (packet_id ごとに 1 ずつ増える) で見る。続いていなければ、組み立て中のものを
+ *   捨てて次の先頭を待つ。**fragment_counter は当てにしない。** 実機のケーブルの BS4K は分割したものでも
+ *   いつも 0 を入れていた
+ * - 短いメッセージは、1 つの MMTP のパケットに長さを前に付けて集約される (aggregation_flag)。
+ *   長さは length_extension_flag が立っていれば 32 ビット、立っていなければ 16 ビット
+ *
+ * 組み立て中のものは、並び (`flow`) と packet_id の組ごとに持つ
+ */
+export class SignalingAssembler {
+    pending = new Map();
+    /** 欠けたか大きすぎて捨てた、組み立て中のメッセージの数 */
+    dropped = 0;
+    /** 信号メッセージを運ぶ MMTP のパケットを 1 つ渡す。そろったメッセージを返す */
+    feed(flow, packet) {
+        const payload = packet.payload;
+        if (packet.payloadType !== PAYLOAD_SIGNALING || payload.length < 2)
+            return [];
+        const fragmentation = payload[0] >> 6;
+        const longLength = (payload[0] & 0x02) !== 0;
+        const aggregated = (payload[0] & 0x01) !== 0;
+        const body = payload.subarray(2);
+        const key = `${flow}/${packet.packetId}`;
+        let whole = null;
+        if (fragmentation === WHOLE) {
+            if (this.pending.delete(key))
+                this.dropped++;
+            whole = body;
+        }
+        else if (fragmentation === FIRST) {
+            if (this.pending.delete(key))
+                this.dropped++;
+            // 断片を持ち越すのでコピーする (中身は届いたチャンクの一部を指す。`TlvStream`)
+            this.pending.set(key, {
+                parts: [body.slice()],
+                size: body.length,
+                sequence: packet.sequenceNumber,
+            });
+        }
+        else {
+            const held = this.pending.get(key);
+            if (held === undefined)
+                return [];
+            held.size += body.length;
+            if (packet.sequenceNumber !== (held.sequence + 1) >>> 0 ||
+                held.size > PENDING_MOST) {
+                this.pending.delete(key);
+                this.dropped++;
+                return [];
+            }
+            held.parts.push(body.slice());
+            held.sequence = packet.sequenceNumber;
+            if (fragmentation === LAST) {
+                this.pending.delete(key);
+                whole = concatBytes(held.parts);
+            }
+        }
+        if (whole === null)
+            return [];
+        return aggregated ? splitAggregated(whole, longLength) : [whole];
+    }
+}
+/** 集約されたメッセージを、前に付いた長さで切り分ける */
+function splitAggregated(data, longLength) {
+    const width = longLength ? 4 : 2;
+    const out = [];
+    let at = 0;
+    while (at + width <= data.length) {
+        const length = longLength ? u32(data, at) : u16(data, at);
+        const end = at + width + length;
+        if (end > data.length)
+            break;
+        out.push(data.subarray(at + width, end));
+        at = end;
+    }
+    return out;
+}

package/dist/psi.d.ts

@@ -1,7 +1,7 @@
 /**
  * TS の土台 (パケットの切り出し・セクションの組み立て・PAT/PMT) と、局の一覧。
  * 局の一覧はチャンネルスキャンで「この物理チャンネルに何が入っているか」を知るために使い、
- * 読むのは NIT と SDT の 2 つ。
+ * 読むのは NIT と SDT の 2 つ。ケーブルでは、局の無い TS を見分けるのに PAT も読む (`ServiceReader`)。
  *
  * - NIT (PID 0x0010) … ネットワーク ID と、地上波ならリモコン番号。衛星はネットワークの全部の TS
  *   (TSID・周波数・サービスの一覧) が載っている (`NitReader`)
@@ -27,6 +27,8 @@ export declare const TABLE_SDT_ACTUAL = 66;
  * 取り込むほう (denpa の epg.ts の DIGITAL_TV)
  */
 export declare const SERVICE_TYPES: Set<number>;
+/** MPEG-2 の CRC32。セクション末尾の 4 バイトを含めて回すと 0 になる */
+export declare function crc32(data: Uint8Array): number;
 /**
  * セクション本体に CRC32 を付けて仕上げる。`section_length` も実長に直す。
  *
@@ -48,8 +50,9 @@ export interface TransportInfo {
 }
 export interface NetworkInfo {
     networkId: number;
+    /** 最初の TS のリモコン番号。地上波の NIT は自分の TS 1 つだけを載せる */
     remoteControlKeyId: number | null;
-    transportStreams: TransportInfo[];
+    transportStreams: NetworkTransport[];
 }
 /**
  * PSI セクションを組み立てる。
@@ -182,6 +185,8 @@ export type Delivery = SatelliteDelivery | TerrestrialDelivery;
 /** NIT の TS の 1 件。サービスの一覧に、どこで流れているかが付く */
 export interface NetworkTransport extends TransportInfo {
     delivery: Delivery | null;
+    /** その TS のリモコン番号 (TS 情報記述子)。載せていなければ null */
+    remoteControlKeyId: number | null;
 }
 /** そろった NIT。セクションをつないだもの */
 export interface Network {
@@ -259,13 +264,26 @@ export interface FoundService extends Service {
  * Mirakurun のスキャンと同じで、**両方**揃って初めてそのチャンネルを
  * 「受信できた」とみなす。SDT だけ取れても、どのネットワークのものか
  * 分からないと設定に書けない。
+ *
+ * **ケーブル (`requireNit: false`) は SDT[actual] だけで揃ったとみなす。** 1 つのネットワークが
+ * 地上波・BS の再送信と自主放送の TS をまとめて流していて、NIT は CATV のネットワークのもの
+ * (局の元の放送とは別)。どの放送の局かは SDT の original_network_id で分かる。
+ * NIT が先に来ていれば、その TS のリモコン番号だけを使う。
+ * PAT に局が 1 つも無い TS (データだけの TS) も揃ったとみなし、局は返さない (`empty`)
  */
 export declare class ServiceReader {
     private readonly nit;
     private readonly sdt;
+    private readonly pat;
     private readonly packets;
+    private readonly requireNit;
     network: NetworkInfo | null;
     transport: TransportInfo | null;
+    /** PAT に局が 1 つも無かった (`requireNit: false` のときだけ読む) */
+    empty: boolean;
+    constructor({ requireNit }?: {
+        requireNit?: boolean;
+    });
     get complete(): boolean;
     /** 任意の長さのバイト列を渡す。揃ったら true */
     feed(chunk: Uint8Array): boolean;

package/dist/psi.js

@@ -1,7 +1,7 @@
 /**
  * TS の土台 (パケットの切り出し・セクションの組み立て・PAT/PMT) と、局の一覧。
  * 局の一覧はチャンネルスキャンで「この物理チャンネルに何が入っているか」を知るために使い、
- * 読むのは NIT と SDT の 2 つ。
+ * 読むのは NIT と SDT の 2 つ。ケーブルでは、局の無い TS を見分けるのに PAT も読む (`ServiceReader`)。
  *
  * - NIT (PID 0x0010) … ネットワーク ID と、地上波ならリモコン番号。衛星はネットワークの全部の TS
  *   (TSID・周波数・サービスの一覧) が載っている (`NitReader`)
@@ -55,7 +55,7 @@ const CRC32_TABLE = (() => {
     return table;
 })();
 /** MPEG-2 の CRC32。セクション末尾の 4 バイトを含めて回すと 0 になる */
-function crc32(data) {
+export function crc32(data) {
     let crc = 0xffffffff;
     for (const byte of data) {
         crc =
@@ -481,11 +481,11 @@ function parseNitSection(section) {
         at += 6 + loop;
         const services = [];
         let delivery = null;
+        let remote = null;
         for (const [tag, descriptor] of descriptors(body)) {
-            if (tag === DESC_TS_INFORMATION &&
-                descriptor.length > 0 &&
-                remoteControlKeyId === null) {
-                remoteControlKeyId = descriptor[0];
+            if (tag === DESC_TS_INFORMATION && descriptor.length > 0) {
+                remote ??= descriptor[0];
+                remoteControlKeyId ??= remote;
             }
             else if (tag === DESC_SERVICE_LIST) {
                 for (let i = 0; i + 3 <= descriptor.length; i += 3) {
@@ -508,13 +508,13 @@ function parseNitSection(section) {
             originalNetworkId,
             services,
             delivery,
+            remoteControlKeyId: remote,
         });
     }
     return {
         other: tableId === TABLE_NIT_OTHER,
         networkId: u16(section, 3),
         version: (section[5] >> 1) & 0x1f,
-        current: (section[5] & 0x01) !== 0,
         sectionNumber: section[6],
         lastSectionNumber: section[7],
         remoteControlKeyId,
@@ -716,15 +716,30 @@ export class SdtReader {
  * Mirakurun のスキャンと同じで、**両方**揃って初めてそのチャンネルを
  * 「受信できた」とみなす。SDT だけ取れても、どのネットワークのものか
  * 分からないと設定に書けない。
+ *
+ * **ケーブル (`requireNit: false`) は SDT[actual] だけで揃ったとみなす。** 1 つのネットワークが
+ * 地上波・BS の再送信と自主放送の TS をまとめて流していて、NIT は CATV のネットワークのもの
+ * (局の元の放送とは別)。どの放送の局かは SDT の original_network_id で分かる。
+ * NIT が先に来ていれば、その TS のリモコン番号だけを使う。
+ * PAT に局が 1 つも無い TS (データだけの TS) も揃ったとみなし、局は返さない (`empty`)
  */
 export class ServiceReader {
     nit = new SectionAssembler(PID_NIT);
     sdt = new SectionAssembler(PID_SDT);
+    pat = new SectionAssembler(PID_PAT);
     packets = new PacketStream();
+    requireNit;
     network = null;
     transport = null;
+    /** PAT に局が 1 つも無かった (`requireNit: false` のときだけ読む) */
+    empty = false;
+    constructor({ requireNit = true } = {}) {
+        this.requireNit = requireNit;
+    }
     get complete() {
-        return this.network !== null && this.transport !== null;
+        return this.requireNit
+            ? this.network !== null && this.transport !== null
+            : this.transport !== null || this.empty;
     }
     /** 任意の長さのバイト列を渡す。揃ったら true */
     feed(chunk) {
@@ -739,16 +754,22 @@ export class ServiceReader {
                     this.transport = parseSdt(section) ?? this.transport;
                 }
             }
+            if (!this.requireNit && !this.empty && this.transport === null) {
+                for (const section of this.pat.feed(packet)) {
+                    if (section[0] === TABLE_PAT && parsePat(section).size === 0)
+                        this.empty = true;
+                }
+            }
         }
         return this.complete;
     }
     /** 録るに値するサービスだけ。リモコン番号は NIT のものを配る */
     services() {
-        if (this.network === null || this.transport === null)
+        const transport = this.transport;
+        if (transport === null)
             return [];
-        const { networkId, remoteControlKeyId } = this.network;
-        const { transportStreamId } = this.transport;
-        return this.transport.services
+        const { transportStreamId, originalNetworkId } = transport;
+        const found = (networkId, remoteControlKeyId) => transport.services
             .filter((service) => SERVICE_TYPES.has(service.serviceType))
             .map((service) => ({
             ...service,
@@ -756,5 +777,13 @@ export class ServiceReader {
             transportStreamId,
             remoteControlKeyId,
         }));
+        if (this.requireNit) {
+            if (this.network === null)
+                return [];
+            return found(this.network.networkId, this.network.remoteControlKeyId);
+        }
+        const own = this.network?.transportStreams.find((ts) => ts.transportStreamId === transportStreamId &&
+            ts.originalNetworkId === originalNetworkId);
+        return found(originalNetworkId, own?.remoteControlKeyId ?? null);
     }
 }

package/dist/synth-mmt-av.d.ts

@@ -0,0 +1,83 @@
+/**
+ * **本物の HEVC と AAC を MMT/TLV に包んで、4K の局の放送を作る** (試験用。`synth-av.ts` の 4K の放送に当たる)。
+ *
+ * 素材は ffmpeg で作り、ここに base64 で持つ (E2E のイメージには本物の ffmpeg が無い)。
+ *
+ * - 映像: `testsrc2` の 64x64・59.94 コマ・16 コマを libx265 で HEVC Main10 にしたもの
+ *   (keyint 8・B ピクチャ 3・閉じた GOP・AUD と VPS/SPS/PPS をキーフレームごとに)。`-f hevc` の Annex B
+ * - 音声: 440 Hz の正弦波を AAC LC (48 kHz・2 チャンネル) にした 13 フレームを `-f latm` (LOAS) で書いたもの
+ *
+ * どちらも 1 つの mp4 から書き出した。そのときの映像の PTS と DTS (180000 の単位、デコードの順) が `VIDEO_TIMES`。
+ * `SynthMmtAv` は映像の GOP (8 コマ) を 1 つの MPU にして繰り返し、時刻と番号を進めながら流し続ける
+ * (偽エージェントの 4K の局。`tests/fake/broadcast.ts`)
+ */
+/** 映像の素材 (HEVC Main10 の Annex B。base64) */
+export declare const HEVC: string;
+/** 音声の素材 (AAC LC の LOAS。base64) */
+export declare const LOAS: string;
+/** ffprobe が読んだ映像の [PTS, DTS] (180000 の単位、デコードの順) */
+export declare const VIDEO_TIMES: [number, number][];
+/** 映像の 1 GOP のコマ数 (keyint) */
+export declare const GOP = 8;
+/** 音声の素材のフレーム数 */
+export declare const AUDIO_FRAMES = 13;
+/** MPT の時刻の単位 (実機の BS4K と同じ) */
+export declare const TIMESCALE = 180000;
+/** base64 をバイト列に */
+export declare function base64Bytes(base64: string): Uint8Array;
+/** Annex B を NAL ユニットに切り、AUD (35) ごとにコマにまとめる (デコードの順) */
+export declare function hevcPictures(annexB: Uint8Array): Uint8Array[][];
+/** LOAS の同期のヘッダー (11 ビットの 0x2B7 と 13 ビットの長さ) を外し、AudioMuxElement を並べる */
+export declare function latmElements(loas: Uint8Array): Uint8Array[];
+/** 4K の局 1 つぶんの組み立ての決まり (`SynthMmtAv`) */
+export interface SynthMmtAvOptions {
+    /** 局の service_id (MPT の MMT_package_id) */
+    serviceId: number;
+    /** MPT の packet_id */
+    mptPacketId: number;
+    /** 映像の packet_id。省くと実機の BS4K と同じ 0xF100 */
+    videoPacketId?: number;
+    /** 音声の packet_id。省くと 0xF110 */
+    audioPacketId?: number;
+    /** 字幕の packet_id。省くと 0xF130 */
+    captionPacketId?: number;
+    /** 映像の最初の MPU の提示時刻 (UNIX 時刻のミリ秒)。放送の時計 (NTP) にして MPT に書く */
+    startMs: number;
+    /** 字幕の文字。省くと字幕を流さない。映像の MPU `CAPTION_EVERY` 個ごとに TTML の文書を 1 つ流す */
+    caption?: string;
+    /** ヘッダー圧縮した IP の CID。省くと 1 */
+    cid?: number;
+}
+/** 映像の 1 MPU の長さ (ミリ秒)。実時間で流すときの間隔 */
+export declare const MPU_MS: number;
+/**
+ * **素材の映像と音声 (と字幕) を、MMT/TLV で流し続ける。** `next` を呼ぶたびに映像の 1 MPU (1 GOP・8 コマ・約 0.13 秒) と、
+ * そこまでに要る音声の MPU を、時刻と番号を進めて返す。どの MPU の前にも、これから来る MPU の時刻を並べた MPT を付ける
+ * (途中から読み始めても、次の MPU から読める)
+ */
+export declare class SynthMmtAv {
+    private readonly options;
+    private readonly video;
+    private readonly audio;
+    private readonly ids;
+    private readonly cid;
+    /** 映像の最初の MPU の提示時刻 (180000 の単位、NTP の始まりから) */
+    private readonly base;
+    /** 次に流す映像の MPU (0 から。mpu_sequence_number) */
+    private k;
+    /** 次に流す音声の MPU (0 から) */
+    private j;
+    /** packet_id ごとの、次の packet_sequence_number */
+    private readonly sequence;
+    constructor(options: SynthMmtAvOptions);
+    /** 180000 の単位の時刻を NTP に */
+    private ntp;
+    /** packet_id ごとに続き番号を振りながら MFU を作る */
+    private mfu;
+    /** 映像の MPU `k` のコマの [PTS, DTS] (180000 の単位、NTP の始まりから。デコードの順) */
+    private videoTimes;
+    /** これから流す映像・音声・字幕の MPU の時刻を並べた MPT */
+    private mpt;
+    /** 映像の 1 MPU と、そこまでの音声 (と字幕) を TLV のバイト列で */
+    next(): Uint8Array;
+}