@danything/arib 2.1.0 → 2.3.0

package/dist/synth-mmt.js

@@ -0,0 +1,476 @@
+/**
+ * 試験用の TLV のバイト列 (TLV・IP・MMTP・MMT-SI) を組み立てる。TS の `synth.ts` と同じ役で、
+ * 読む側 (`tlv.ts`・`tlv-ip.ts`・`mmtp.ts`・`mmt-si.ts`・`mh-eit.ts`・`mmt-service-filter.ts`・`mmt-media.ts`) と対になる書く側。
+ *
+ * スクランブルは印 (ヘッダー拡張) だけを付け、中身は暗号にしない。
+ */
+import { concatBytes } from "./bytes.js";
+import { withCrc } from "./psi.js";
+import { bcdDuration, mjdTime } from "./synth.js";
+import { TLV_COMPRESSED_IP, TLV_IPV6, TLV_SIGNALING } from "./tlv.js";
+const be = (value) => [(value >> 8) & 0xff, value & 0xff];
+const be32 = (value) => [...be(value >>> 16), ...be(value & 0xffff)];
+const utf8 = (text) => [...new TextEncoder().encode(text)];
+const JPN = [0x6a, 0x70, 0x6e];
+/** TLV のパケット 1 つ */
+export function tlvPacket(type, payload) {
+    const body = Uint8Array.from(payload);
+    return Uint8Array.from([0x7f, type, ...be(body.length), ...body]);
+}
+/** IPv6 のアドレスを 16 バイトに (`ff3e::a000:1000` のような縮めた形も読む) */
+function ipv6Bytes(text) {
+    const [head = "", tail] = text.split("::");
+    const groups = (part) => part === "" ? [] : part.split(":").map((g) => parseInt(g, 16));
+    const front = groups(head);
+    const back = tail === undefined ? [] : groups(tail);
+    const zeros = new Array(8 - front.length - back.length).fill(0);
+    return [...front, ...zeros, ...back].flatMap(be);
+}
+/**
+ * ヘッダー圧縮した IP の TLV パケット。`address` を渡せば全部のヘッダー (圧縮の種類 0x60)、
+ * 渡さなければヘッダー無し (0x61)
+ */
+export function compressedIp(cid, payload, address, sequence = 0) {
+    const head = [(cid >> 4) & 0xff, ((cid & 0x0f) << 4) | (sequence & 0x0f)];
+    if (address === undefined)
+        return tlvPacket(TLV_COMPRESSED_IP, [...head, 0x61, ...payload]);
+    const ip = [
+        0x60,
+        0x00,
+        0x00,
+        0x00, // version・traffic class・flow label
+        17, // next header (UDP)
+        0x40, // hop limit
+        ...ipv6Bytes(address.source ?? "2401:dbc0:1003::b111"),
+        ...ipv6Bytes(address.destination ?? "ff3e::a000:1000"),
+        ...be(address.sourcePort ?? 50000),
+        ...be(address.destinationPort ?? 51216),
+    ];
+    return tlvPacket(TLV_COMPRESSED_IP, [...head, 0x60, ...ip, ...payload]);
+}
+/** 素の IPv6 の UDP の TLV パケット (NTP など) */
+export function ipv6Udp(destination, destinationPort, payload) {
+    const udp = [
+        ...be(destinationPort),
+        ...be(destinationPort),
+        ...be(8 + payload.length),
+        0x00,
+        0x00,
+        ...payload,
+    ];
+    return tlvPacket(TLV_IPV6, [
+        0x60,
+        0x00,
+        0x00,
+        0x00,
+        ...be(udp.length),
+        17,
+        0x01,
+        ...ipv6Bytes("fe80::1"),
+        ...ipv6Bytes(destination),
+        ...udp,
+    ]);
+}
+/** TLV-SI の TLV パケット。セクションを並べ、残りは詰めない */
+export function tlvSi(...sections) {
+    return tlvPacket(TLV_SIGNALING, concatBytes(sections));
+}
+const SCRAMBLING_BITS = {
+    none: 0,
+    even: 2,
+    odd: 3,
+};
+/** MMTP のパケット 1 つ (UDP の中身) */
+export function mmtpPacket(packet) {
+    const extension = packet.scrambling === undefined
+        ? []
+        : [
+            // 種類がいくつも入る拡張 (0x0000) の中に、スクランブルの印 (種類 0x0001・長さ 1。上位 1 ビットは「これで終わり」)
+            ...be(0x0000),
+            ...be(5),
+            ...be(0x8001),
+            ...be(1),
+            (SCRAMBLING_BITS[packet.scrambling] << 6) | 0x3f,
+        ];
+    return Uint8Array.from([
+        // version 0、packet_counter_flag 0、FEC 0、extension_flag、RAP_flag
+        (extension.length > 0 ? 0x02 : 0) | (packet.rap === true ? 0x01 : 0),
+        packet.payloadType & 0x3f,
+        ...be(packet.packetId),
+        ...be32(0), // delivery_timestamp
+        ...be32(packet.sequenceNumber ?? 0),
+        ...extension,
+        ...packet.payload,
+    ]);
+}
+/** MPU のパケットの中身 (ペイロードヘッダー 8 バイトと、その後ろ) */
+export function mpuPayload(data, mpuSequenceNumber = 0) {
+    const body = [
+        0x28, // fragment_type 2 (MFU)、timed、分割なし、集約なし
+        0x00,
+        ...be32(mpuSequenceNumber),
+        ...data,
+    ];
+    return Uint8Array.from([...be(body.length), ...body]);
+}
+/** 時刻のあるデータユニットのヘッダー (14 バイト。offset はサンプルの中の位置) */
+function timedHeader(sample, offset) {
+    return [...be32(0), ...be32(sample), ...be32(offset), 0x00, 0x00];
+}
+/**
+ * MPU の中身 (MFU) を運ぶ MMTP のパケットの並び。データユニットは時刻のあるもの (映像・音声・字幕)。
+ * 分割したデータユニットは、断片ごとにヘッダーを付ける
+ */
+export function mfuPackets(packetId, mpuSequenceNumber, units, options = {}) {
+    const start = options.sequenceNumber ?? 0;
+    let sequenceNumber = start;
+    const packet = (indicator, aggregated, body) => {
+        const payload = [
+            // fragment_type 2 (MFU)、timed、分割の印、集約の印
+            0x28 | (indicator << 1) | (aggregated ? 0x01 : 0),
+            0x00,
+            ...be32(mpuSequenceNumber),
+            ...body,
+        ];
+        return mmtpPacket({
+            packetId,
+            payloadType: 0,
+            rap: sequenceNumber === start && options.rap === true,
+            sequenceNumber: sequenceNumber++,
+            payload: [...be(payload.length), ...payload],
+        });
+    };
+    if (options.aggregate === true) {
+        const body = units.flatMap((unit) => {
+            const du = [...timedHeader(unit.sample, 0), ...unit.data];
+            return [...be(du.length), ...du];
+        });
+        return [packet(0, true, body)];
+    }
+    const out = [];
+    for (const unit of units) {
+        const data = [...unit.data];
+        const size = options.fragment ?? data.length;
+        if (data.length <= size) {
+            out.push(packet(0, false, [...timedHeader(unit.sample, 0), ...data]));
+            continue;
+        }
+        for (let at = 0; at < data.length; at += size) {
+            const indicator = at === 0 ? 1 : at + size >= data.length ? 3 : 2;
+            out.push(packet(indicator, false, [
+                ...timedHeader(unit.sample, at),
+                ...data.slice(at, at + size),
+            ]));
+        }
+    }
+    return out;
+}
+/** MPU タイムスタンプ記述子。MPU ごとに `[mpu_sequence_number, 最初の提示時刻]` */
+export function mpuTimestampDescriptor(mpus) {
+    return mmtDescriptor(0x0001, mpus.flatMap(([sequence, [seconds, fraction]]) => [
+        ...be32(sequence),
+        ...be32(seconds),
+        ...be32(fraction),
+    ]));
+}
+/**
+ * MPU 拡張タイムスタンプ記述子。`duration` を渡せば pts_offset をどれも同じ値で書き (種類 1。実機の BS4K はこれ)、
+ * 渡さなければアクセスユニットごとに書く (種類 2)
+ */
+export function mpuExtendedTimestampDescriptor(timescale, mpus, duration) {
+    const type = duration === undefined ? 2 : 1;
+    return mmtDescriptor(0x8026, [
+        0xf8 | (type << 1) | 0x01,
+        ...be32(timescale),
+        ...(duration === undefined ? [] : be(duration)),
+        ...mpus.flatMap((mpu) => [
+            ...be32(mpu.sequence),
+            0x3f,
+            ...be(mpu.decodingOffset),
+            mpu.dtsPtsOffsets.length,
+            ...mpu.dtsPtsOffsets.flatMap((offset, i) => [
+                ...be(offset),
+                ...(type === 2 ? be(mpu.durations?.[i] ?? 0) : []),
+            ]),
+        ]),
+    ]);
+}
+/** ビットを詰めていく (LATM を書くため) */
+class BitWriter {
+    bytes = [];
+    at = 0;
+    put(value, count) {
+        for (let i = count - 1; i >= 0; i--) {
+            if (this.at % 8 === 0)
+                this.bytes.push(0);
+            if (Math.floor(value / 2 ** i) % 2)
+                this.bytes[this.bytes.length - 1] |= 0x80 >> (this.at % 8);
+            this.at++;
+        }
+        return this;
+    }
+    get done() {
+        return Uint8Array.from(this.bytes);
+    }
+}
+/**
+ * LATM の AudioMuxElement (muxConfigPresent = 1。LOAS の同期のヘッダーは付けない)。
+ * `audioSpecificConfig` を渡せば StreamMuxConfig を書き、渡さなければ「前と同じ」にする。
+ * AudioSpecificConfig は、長さがバイトの区切りに揃うもの (AAC LC の 2 バイトなど) を渡す
+ */
+export function latmElement(frame, audioSpecificConfig) {
+    const bits = new BitWriter();
+    bits.put(audioSpecificConfig === undefined ? 1 : 0, 1);
+    if (audioSpecificConfig !== undefined) {
+        // audioMuxVersion 0、allStreamsSameTimeFraming 1、サブフレーム・番組・層は 1 つずつ
+        bits.put(0, 1).put(1, 1).put(0, 6).put(0, 4).put(0, 3);
+        for (const byte of audioSpecificConfig)
+            bits.put(byte, 8);
+        // frameLengthType 0、latmBufferFullness 0xFF、otherData なし、CRC なし
+        bits.put(0, 3).put(0xff, 8).put(0, 1).put(0, 1);
+    }
+    let left = frame.length;
+    for (; left >= 255; left -= 255)
+        bits.put(255, 8);
+    bits.put(left, 8);
+    for (const byte of frame)
+        bits.put(byte, 8);
+    return bits.done;
+}
+/** PA メッセージ。表 (MPT・PLT) を並べる */
+export function paMessage(...tables) {
+    const body = [
+        tables.length,
+        ...tables.flatMap((table) => [table[0], table[1], table[2], table[3]]),
+        ...tables.flatMap((table) => [...table]),
+    ];
+    return Uint8Array.from([...be(0x0000), 0x00, ...be32(body.length), ...body]);
+}
+/** M2 セクションメッセージ。セクション (MH-EIT・MH-SDT・ECM など) を 1 つ運ぶ */
+export function m2SectionMessage(section) {
+    return Uint8Array.from([
+        ...be(0x8000),
+        0x00,
+        ...be(section.length),
+        ...section,
+    ]);
+}
+/**
+ * 信号メッセージを運ぶ MMTP のパケットの並び。集約するときは全部を 1 つに、分割するときは 1 つのメッセージを
+ * いくつものパケットに分ける。fragment_counter は実機と同じく 0 のまま
+ */
+export function signalingPackets(packetId, messages, options = {}) {
+    let sequenceNumber = options.sequenceNumber ?? 0;
+    const packet = (indicator, flags, body) => mmtpPacket({
+        packetId,
+        payloadType: 2,
+        sequenceNumber: sequenceNumber++,
+        payload: [(indicator << 6) | flags, 0x00, ...body],
+    });
+    if (options.aggregate !== undefined) {
+        const long = options.aggregate === "long";
+        const body = messages.flatMap((message) => [
+            ...(long ? be32(message.length) : be(message.length)),
+            ...message,
+        ]);
+        return [packet(0, (long ? 0x02 : 0) | 0x01, body)];
+    }
+    const out = [];
+    for (const message of messages) {
+        const size = options.fragment ?? message.length;
+        if (message.length <= size) {
+            out.push(packet(0, 0, [...message]));
+            continue;
+        }
+        for (let at = 0; at < message.length; at += size) {
+            const last = at + size >= message.length;
+            const indicator = at === 0 ? 1 : last ? 3 : 2;
+            out.push(packet(indicator, 0, [...message.subarray(at, at + size)]));
+        }
+    }
+    return out;
+}
+/** PLT。package ごとに `[package_id, MPT の packet_id]` */
+export function pltTable(packages, version = 0) {
+    const body = [
+        packages.length,
+        ...packages.flatMap(([packageId, packetId]) => [
+            2,
+            ...be(packageId),
+            0x00,
+            ...be(packetId),
+        ]),
+        0x00, // IP_delivery の数
+    ];
+    return Uint8Array.from([0x80, version, ...be(body.length), ...body]);
+}
+/** MMT の記述子。タグが 0xF000 以上なら長さは 2 バイト */
+export function mmtDescriptor(tag, body) {
+    return tag >= 0xf000
+        ? [...be(tag), ...be(body.length), ...body]
+        : [...be(tag), body.length, ...body];
+}
+/** MPT。アセットはどれも同じ IP の並びの packet_id (在りかの種類 0) に置く */
+export function mptTable(mpt) {
+    const descriptors = mpt.access === undefined
+        ? []
+        : mmtDescriptor(0x8004, [
+            ...be(mpt.access.caSystemId),
+            0x00,
+            ...be(mpt.access.ecmPacketId),
+        ]);
+    const assets = mpt.assets.flatMap((asset) => {
+        const assetDescriptors = [
+            ...(asset.componentTag === undefined
+                ? []
+                : mmtDescriptor(0x8011, be(asset.componentTag))),
+            ...(asset.descriptors ?? []),
+        ];
+        return [
+            0x00, // identifier_type
+            ...be32(0), // asset_id_scheme
+            2,
+            ...be(asset.packetId), // asset_id
+            ...[...asset.type].map((c) => c.charCodeAt(0)),
+            0xfe, // asset_clock_relation_flag 0
+            1, // location_count
+            0x00,
+            ...be(asset.packetId),
+            ...be(assetDescriptors.length),
+            ...assetDescriptors,
+        ];
+    });
+    const body = [
+        0xfc, // MPT_mode 0
+        2,
+        ...be(mpt.packageId),
+        ...be(descriptors.length),
+        ...descriptors,
+        mpt.assets.length,
+        ...assets,
+    ];
+    return Uint8Array.from([0x20, mpt.version ?? 0, ...be(body.length), ...body]);
+}
+/** MMT の表のセクションの頭 (table_id・長さ・拡張・バージョン・セクション番号)。長さは `withCrc` が埋める */
+function head(tableId, extension, version = 0) {
+    return [tableId, 0x00, 0x00, ...be(extension), 0xc1 | (version << 1), 0, 0];
+}
+/** MH-SDT。`other` なら MH-SDT[other] (0xA0) */
+export function mhSdtSection(tlvStreamId, originalNetworkId, services, other = false) {
+    const body = [
+        ...head(other ? 0xa0 : 0x9f, tlvStreamId),
+        ...be(originalNetworkId),
+        0xff,
+    ];
+    for (const service of services) {
+        const provider = utf8(service.providerName ?? "");
+        const name = utf8(service.name);
+        const descriptor = mmtDescriptor(0x8019, [
+            service.serviceType ?? 0x01,
+            provider.length,
+            ...provider,
+            name.length,
+            ...name,
+        ]);
+        body.push(...be(service.serviceId), 0xe3, // EIT の予定と p/f がある
+        0x80 | ((descriptor.length >> 8) & 0x0f), // running_status 4、free_CA_mode 0
+        descriptor.length & 0xff, ...descriptor);
+    }
+    return withCrc(body);
+}
+/** TLV-NIT。TLV のストリームごとに `[tlv_stream_id, original_network_id, [service_id, 種類][]]` */
+export function tlvNitSection(networkId, name, streams) {
+    const nameBytes = utf8(name);
+    const network = [0x40, nameBytes.length, ...nameBytes];
+    const loop = streams.flatMap(([tlvStreamId, onid, services]) => {
+        const list = services.flatMap(([serviceId, type]) => [
+            ...be(serviceId),
+            type,
+        ]);
+        const descriptors = [0x41, list.length, ...list];
+        return [
+            ...be(tlvStreamId),
+            ...be(onid),
+            ...be(0xf000 | descriptors.length),
+            ...descriptors,
+        ];
+    });
+    return withCrc([
+        ...head(0x40, networkId),
+        ...be(0xf000 | network.length),
+        ...network,
+        ...be(0xf000 | loop.length),
+        ...loop,
+    ]);
+}
+/** MH-TOT。放送の現在時刻 */
+export function mhTotSection(unixMs) {
+    return withCrc([0xa1, 0x00, 0x00, ...mjdTime(unixMs), 0xf0, 0x00]);
+}
+function eventDescriptors(event) {
+    const name = utf8(event.name);
+    const text = utf8(event.description ?? "");
+    const out = mmtDescriptor(0xf001, [
+        ...JPN,
+        name.length,
+        ...name,
+        ...be(text.length),
+        ...text,
+    ]);
+    for (const [heading, body] of event.extended ?? []) {
+        const bytes = utf8(body);
+        const size = event.split ?? bytes.length;
+        const items = [];
+        for (let at = 0; at < bytes.length; at += size) {
+            const title = at === 0 ? utf8(heading) : [];
+            const part = bytes.slice(at, at + size);
+            items.push(title.length, ...title, ...be(part.length), ...part);
+        }
+        out.push(...mmtDescriptor(0xf002, [
+            0x00,
+            ...JPN,
+            ...be(items.length),
+            ...items,
+            0x00,
+            0x00,
+        ]));
+    }
+    if (event.genres !== undefined)
+        out.push(...mmtDescriptor(0x8012, event.genres.flatMap(([lv1, lv2]) => [(lv1 << 4) | lv2, 0xff])));
+    if (event.resolution !== undefined)
+        // 16:9、プログレッシブ、59.94 コマ、component_tag 0、言語
+        out.push(...mmtDescriptor(0x8010, [
+            (event.resolution << 4) | 0x03,
+            0xe8,
+            0x00,
+            0x00,
+            0x5f,
+            ...JPN,
+        ]));
+    if (event.copyControl !== undefined)
+        out.push(...mmtDescriptor(0x8038, [(event.copyControl << 6) | 0x0f, 0xff]));
+    return out;
+}
+/** MH-EIT */
+export function mhEitSection(options) {
+    const body = [
+        options.tableId,
+        0x00,
+        0x00,
+        ...be(options.serviceId),
+        0xc1 | ((options.version ?? 0) << 1),
+        options.sectionNumber ?? 0,
+        options.lastSectionNumber ?? 0,
+        ...be(options.tlvStreamId),
+        ...be(options.originalNetworkId),
+        options.lastSectionNumber ?? 0,
+        options.lastTableId ?? options.tableId,
+    ];
+    for (const event of options.events) {
+        const descriptors = eventDescriptors(event);
+        body.push(...be(event.eventId), ...mjdTime(event.startAt), ...bcdDuration(event.duration), ((options.runningStatus ?? 0) << 5) |
+            (event.isFree === false ? 0x10 : 0) |
+            ((descriptors.length >> 8) & 0x0f), descriptors.length & 0xff, ...descriptors);
+    }
+    return withCrc(body);
+}

package/dist/synth.d.ts

@@ -2,7 +2,7 @@
  * TS のセクションを組み立てる。
  *
  * 実チューナーが無いので、解析のテストにも偽エージェントにも「それらしい TS」が要る。
- * 読む側 (psi.ts・eit.ts・dsmcc.ts・ait.ts、denpa の logo.ts など) と対になる書く側で、仕様を書き写しているのはここだけ。
+ * 読む側 (psi.ts・eit.ts・dsmcc.ts・ait.ts、denpa の logo.ts など) と対になる書く側で、TS の PSI・SI の仕様を書き写しているのはここだけ。
  */
 import { withCrc } from "./psi.js";
 export { withCrc };
@@ -27,6 +27,10 @@ export declare function sdtSection(transportStreamId: number, originalNetworkId:
 options?: SectionPart & {
     other?: boolean;
 }): Uint8Array;
+/** epoch ms → MJD + BCD の 5 バイト。放送の時刻は日本時間で書く */
+export declare function mjdTime(at: number): number[];
+/** ms → BCD 3 バイトの尺 */
+export declare function bcdDuration(ms: number): number[];
 export interface SynthEvent {
     eventId: number;
     /** epoch ms */

package/dist/synth.js

@@ -2,7 +2,7 @@
  * TS のセクションを組み立てる。
  *
  * 実チューナーが無いので、解析のテストにも偽エージェントにも「それらしい TS」が要る。
- * 読む側 (psi.ts・eit.ts・dsmcc.ts・ait.ts、denpa の logo.ts など) と対になる書く側で、仕様を書き写しているのはここだけ。
+ * 読む側 (psi.ts・eit.ts・dsmcc.ts・ait.ts、denpa の logo.ts など) と対になる書く側で、TS の PSI・SI の仕様を書き写しているのはここだけ。
  */
 import { joinBytes } from "./bytes.js";
 import { PACKET, SYNC, withCrc } from "./psi.js";
@@ -120,7 +120,7 @@ options = {}) {
 /** 2 桁の 10 進を BCD の 1 バイトに */
 const bcd = (value) => ((Math.floor(value / 10) << 4) | (value % 10)) & 0xff;
 /** epoch ms → MJD + BCD の 5 バイト。放送の時刻は日本時間で書く */
-function mjdTime(at) {
+export function mjdTime(at) {
     const jst = Math.floor(at / 1000) + 9 * 3600;
     const mjd = Math.floor(jst / 86400) + 40587;
     const rest = ((jst % 86400) + 86400) % 86400;
@@ -132,7 +132,7 @@ function mjdTime(at) {
     ];
 }
 /** ms → BCD 3 バイトの尺 */
-function bcdDuration(ms) {
+export function bcdDuration(ms) {
     const total = Math.floor(ms / 1000);
     return [
         bcd(Math.floor(total / 3600)),
@@ -410,7 +410,7 @@ export function bxmlDescriptor(options = {}) {
     const body = [
         ...be(dataComponentId),
         // 伝送方式 00 / 入口 / 自動起動 / 解像度 0011 (960x540)
-        ...(entryPoint ? [0x33, 0x70] : [0x00, 0xff]),
+        ...(entryPoint ? [0x33, 0x70] : [0x00]),
         0xf8, // dataEventId 0xF / event_section_flag
         0xa0, // 即時取得あり / 蓄積不可 / 起動優先
     ];

package/dist/tlv-ip.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TLV パケットに入った IP を読み、UDP の中身 (MMTP・NTP) を返す (ARIB STD-B32 第 3 部)。
+ *
+ * 4K の放送の映像・音声・信号は、IPv6 の UDP で運ぶ MMTP に入っている。帯域を節約するため、
+ * ほとんどのパケットは IP と UDP のヘッダーを省いた「ヘッダー圧縮した IP」(TLV の種類 0x03) で来る。
+ * 同じ宛先の並びには CID (context_id) が振られ、ときどき来る全部のヘッダー (圧縮の種類 0x60) で
+ * 宛先を知らせ、あいだは CID だけ (0x61) になる。
+ *
+ * 実機 (ケーブルで受けた BS4K) で来たのは、0x60 と 0x61 のほかは NTP を運ぶ素の IPv6 だけだった。
+ * IPv4 の圧縮 (0x20・0x21) は来ていないので読まない。
+ */
+import { type TlvPacket } from "./tlv.js";
+/** UDP の宛先と送り元 */
+export interface UdpAddress {
+    source: string;
+    destination: string;
+    sourcePort: number;
+    destinationPort: number;
+}
+export interface UdpDatagram {
+    /**
+     * 同じ宛先の並びを見分けるキー。圧縮したものは `cid:<CID>`、圧縮していないものは宛先のアドレスとポート。
+     * MMTP の packet_id はこの並びの中でだけ決まっている
+     */
+    flow: string;
+    /** 宛先と送り元。0x61 の CID の 0x60 をまだ受けていなければ null */
+    address: UdpAddress | null;
+    payload: Uint8Array;
+}
+/** IPv6 のアドレス 16 バイトを文字列に (0 の続く所は縮めず、各グループの先頭の 0 だけ落とす) */
+export declare function ipv6Text(data: Uint8Array, at: number): string;
+/**
+ * TLV パケットから UDP を取り出す。**CID ごとの宛先を覚える**ので、1 つの TLV のストリームに 1 つ使う。
+ *
+ * 圧縮したものは、CID の宛先をまだ知らなくても中身を返す (`address` が null)。
+ * 圧縮できるのは UDP だけなので中身は UDP の中身と決まっていて、MMTP は宛先を知らなくても読める。
+ * 全部のヘッダーは 1 秒に 10 回ほどしか来ないので、待つと選局したての 0.1 秒ぶんを捨てることになる
+ */
+export declare class TlvIpReader {
+    private readonly contexts;
+    /** IP を運ぶ TLV パケットでなければ・UDP でなければ null */
+    read(packet: TlvPacket): UdpDatagram | null;
+    private compressed;
+}

package/dist/tlv-ip.js

@@ -0,0 +1,118 @@
+/**
+ * TLV パケットに入った IP を読み、UDP の中身 (MMTP・NTP) を返す (ARIB STD-B32 第 3 部)。
+ *
+ * 4K の放送の映像・音声・信号は、IPv6 の UDP で運ぶ MMTP に入っている。帯域を節約するため、
+ * ほとんどのパケットは IP と UDP のヘッダーを省いた「ヘッダー圧縮した IP」(TLV の種類 0x03) で来る。
+ * 同じ宛先の並びには CID (context_id) が振られ、ときどき来る全部のヘッダー (圧縮の種類 0x60) で
+ * 宛先を知らせ、あいだは CID だけ (0x61) になる。
+ *
+ * 実機 (ケーブルで受けた BS4K) で来たのは、0x60 と 0x61 のほかは NTP を運ぶ素の IPv6 だけだった。
+ * IPv4 の圧縮 (0x20・0x21) は来ていないので読まない。
+ */
+import { u16 } from "./bytes.js";
+import { TLV_COMPRESSED_IP, TLV_IPV4, TLV_IPV6, } from "./tlv.js";
+/** 0x60: IPv6 のヘッダー (payload_length を除いた 38 バイト) と UDP のヘッダー (length と checksum を除いた 4 バイト) */
+const COMPRESSED_IPV6_UDP = 0x60;
+/** 0x61: ヘッダー無し。宛先は同じ CID の 0x60 で知らせたもの */
+const COMPRESSED_NONE = 0x61;
+const COMPRESSED_HEAD = 3;
+const PARTIAL_IPV6 = 38;
+const PARTIAL_UDP = 4;
+const IPV6_HEADER = 40;
+const UDP_HEADER = 8;
+const PROTOCOL_UDP = 17;
+/** IPv6 のアドレス 16 バイトを文字列に (0 の続く所は縮めず、各グループの先頭の 0 だけ落とす) */
+export function ipv6Text(data, at) {
+    const groups = [];
+    for (let i = 0; i < 16; i += 2)
+        groups.push(u16(data, at + i).toString(16));
+    return groups.join(":");
+}
+function ipv4Text(data, at) {
+    return [0, 1, 2, 3].map((i) => data[at + i]).join(".");
+}
+/**
+ * TLV パケットから UDP を取り出す。**CID ごとの宛先を覚える**ので、1 つの TLV のストリームに 1 つ使う。
+ *
+ * 圧縮したものは、CID の宛先をまだ知らなくても中身を返す (`address` が null)。
+ * 圧縮できるのは UDP だけなので中身は UDP の中身と決まっていて、MMTP は宛先を知らなくても読める。
+ * 全部のヘッダーは 1 秒に 10 回ほどしか来ないので、待つと選局したての 0.1 秒ぶんを捨てることになる
+ */
+export class TlvIpReader {
+    contexts = new Map();
+    /** IP を運ぶ TLV パケットでなければ・UDP でなければ null */
+    read(packet) {
+        const data = packet.payload;
+        switch (packet.type) {
+            case TLV_COMPRESSED_IP:
+                return this.compressed(data);
+            case TLV_IPV6:
+                return ipv6(data);
+            case TLV_IPV4:
+                return ipv4(data);
+            default:
+                return null;
+        }
+    }
+    compressed(data) {
+        if (data.length < COMPRESSED_HEAD)
+            return null;
+        // CID (12 ビット) と sequence number (4 ビット)、圧縮の種類
+        const cid = u16(data, 0) >> 4;
+        const flow = `cid:${cid}`;
+        switch (data[2]) {
+            case COMPRESSED_IPV6_UDP: {
+                const at = COMPRESSED_HEAD;
+                const payloadAt = at + PARTIAL_IPV6 + PARTIAL_UDP;
+                if (data.length < payloadAt)
+                    return null;
+                // 38 バイトの並びは version・traffic class・flow label (4)、next header (1)、hop limit (1)、送り元 (16)、宛先 (16)
+                const address = {
+                    source: ipv6Text(data, at + 6),
+                    destination: ipv6Text(data, at + 22),
+                    sourcePort: u16(data, at + PARTIAL_IPV6),
+                    destinationPort: u16(data, at + PARTIAL_IPV6 + 2),
+                };
+                this.contexts.set(cid, address);
+                return { flow, address, payload: data.subarray(payloadAt) };
+            }
+            case COMPRESSED_NONE:
+                return {
+                    flow,
+                    address: this.contexts.get(cid) ?? null,
+                    payload: data.subarray(COMPRESSED_HEAD),
+                };
+            default:
+                return null;
+        }
+    }
+}
+/** 素の IPv6 の UDP。拡張ヘッダーの付いたものは読まない (来ていない) */
+function ipv6(data) {
+    if (data.length < IPV6_HEADER + UDP_HEADER || data[6] !== PROTOCOL_UDP)
+        return null;
+    const end = Math.min(data.length, IPV6_HEADER + u16(data, 4));
+    return udp(data, ipv6Text(data, 8), ipv6Text(data, 24), IPV6_HEADER, end);
+}
+function ipv4(data) {
+    if (data.length < 20 || data[9] !== PROTOCOL_UDP)
+        return null;
+    const header = (data[0] & 0x0f) * 4;
+    const end = Math.min(data.length, u16(data, 2));
+    return udp(data, ipv4Text(data, 12), ipv4Text(data, 16), header, end);
+}
+function udp(data, source, destination, at, end) {
+    if (at + UDP_HEADER > end)
+        return null;
+    const address = {
+        source,
+        destination,
+        sourcePort: u16(data, at),
+        destinationPort: u16(data, at + 2),
+    };
+    return {
+        flow: `${destination}:${address.destinationPort}`,
+        address,
+        payload: data.subarray(at + UDP_HEADER, Math.min(end, at + u16(data, at + 4))),
+    };
+}