@danything/arib 0.0.0-stage → 0.1.0

package/dist/language.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ISO 639-2 のうち日本の放送で出てくるもの。
+ *
+ * **音声も字幕も同じ表を使う** — 字幕と音声で別に持っていた頃は
+ * 4つ足りず、同じ放送の音声が「イタリア語」、字幕が「ita」と出る形になっていた
+ */
+export declare const LANGUAGE: Record<string, string>;

package/dist/language.js

@@ -0,0 +1,20 @@
+/**
+ * ISO 639-2 のうち日本の放送で出てくるもの。
+ *
+ * **音声も字幕も同じ表を使う** — 字幕と音声で別に持っていた頃は
+ * 4つ足りず、同じ放送の音声が「イタリア語」、字幕が「ita」と出る形になっていた
+ */
+export const LANGUAGE = {
+    jpn: "日本語",
+    eng: "英語",
+    deu: "ドイツ語",
+    fra: "フランス語",
+    ita: "イタリア語",
+    rus: "ロシア語",
+    zho: "中国語",
+    kor: "韓国語",
+    spa: "スペイン語",
+    por: "ポルトガル語",
+    tha: "タイ語",
+    etc: "その他",
+};

package/dist/multipart.d.ts

@@ -0,0 +1,43 @@
+/**
+ * モジュールの中身を読む。**ヘッダ + 空行 + 本体** の形式 (STD-B24 第二編 第9章) で、
+ * 多くは `multipart/mixed` に BML と画像がまとめて入っている。
+ *
+ *     Content-Type: multipart/mixed; boundary=XXX
+ *
+ *     --XXX
+ *     Content-Type: text/X-arib-bml; charset="EUC-JP"
+ *     Content-Location: startup.bml
+ *
+ *     <?xml ...
+ *     --XXX--
+ *
+ * もとは web-bml の `entity_parser.ts` を借りていた。運用される形式は上のとおり狭いので、
+ * RFC 2068 の字句を全部なぞらず、**ヘッダの行を取り出して `Content-Type` をデコードし、
+ * 区切りで切る**だけにしてある。
+ */
+import type { MediaType } from "./bml-protocol.js";
+/** ヘッダ 1 つ。名前は小文字にそろえる */
+export interface EntityHeader {
+    name: string;
+    value: string;
+}
+/** 読んだ中身。`multipart/mixed` なら `parts` に1つずつ入る */
+export interface Entity {
+    headers: EntityHeader[];
+    body: Uint8Array;
+    parts: Entity[] | null;
+}
+/**
+ * `type/subtype; a=b; c="d"` を読む。名前は小文字にそろえ、元の綴りも残す。
+ *
+ * **引数の途中で崩れていても、読めたところまでは返す** — 型と下位型が分かれば
+ * 読み方は決まる。型すら読めなければ null
+ */
+export declare function parseMediaType(text: string): MediaType | null;
+/**
+ * 中身を1つ読む。**ヘッダの終わり (空行) が無いものは null** — どこからが本体か
+ * 分からない。`multipart/mixed` なら中までデコードする (入れ子も同じ形)。
+ *
+ * @param part multipart の中の部品か。部品はヘッダの行でちょうど終わってよい (下の説明)
+ */
+export declare function readEntity(data: Uint8Array, part?: boolean): Entity | null;

package/dist/multipart.js

@@ -0,0 +1,194 @@
+/**
+ * モジュールの中身を読む。**ヘッダ + 空行 + 本体** の形式 (STD-B24 第二編 第9章) で、
+ * 多くは `multipart/mixed` に BML と画像がまとめて入っている。
+ *
+ *     Content-Type: multipart/mixed; boundary=XXX
+ *
+ *     --XXX
+ *     Content-Type: text/X-arib-bml; charset="EUC-JP"
+ *     Content-Location: startup.bml
+ *
+ *     <?xml ...
+ *     --XXX--
+ *
+ * もとは web-bml の `entity_parser.ts` を借りていた。運用される形式は上のとおり狭いので、
+ * RFC 2068 の字句を全部なぞらず、**ヘッダの行を取り出して `Content-Type` をデコードし、
+ * 区切りで切る**だけにしてある。
+ */
+const CR = 0x0d;
+const LF = 0x0a;
+const CRLF = Uint8Array.of(CR, LF);
+const utf8 = new TextDecoder();
+const encoder = new TextEncoder();
+/** token に使えない字 (RFC 2068 2.2 の tspecials と制御文字) */
+const TSPECIALS = '()<>@,;:\\"/[]?={} \t';
+function isTokenChar(char) {
+    const code = char.charCodeAt(0);
+    return code > 0x20 && code < 0x7f && !TSPECIALS.includes(char);
+}
+/**
+ * `type/subtype; a=b; c="d"` を読む。名前は小文字にそろえ、元の綴りも残す。
+ *
+ * **引数の途中で崩れていても、読めたところまでは返す** — 型と下位型が分かれば
+ * 読み方は決まる。型すら読めなければ null
+ */
+export function parseMediaType(text) {
+    let at = 0;
+    const skipSpace = () => {
+        while (at < text.length && (text[at] === " " || text[at] === "\t"))
+            at++;
+    };
+    const token = () => {
+        const from = at;
+        while (at < text.length && isTokenChar(text[at]))
+            at++;
+        return at === from ? null : text.slice(from, at);
+    };
+    const quoted = () => {
+        if (text[at] !== '"')
+            return null;
+        at++;
+        let out = "";
+        while (at < text.length && text[at] !== '"') {
+            if (text[at] === "\\" && at + 1 < text.length)
+                at++;
+            out += text[at++];
+        }
+        at++;
+        return out;
+    };
+    skipSpace();
+    const type = token();
+    if (type === null)
+        return null;
+    const parameters = [];
+    const made = (subtype) => ({
+        type: type.toLowerCase(),
+        originalType: type,
+        subtype: subtype.toLowerCase(),
+        originalSubtype: subtype,
+        parameters,
+    });
+    if (text[at] !== "/")
+        return made("");
+    at++;
+    const subtype = token() ?? "";
+    skipSpace();
+    while (text[at] === ";") {
+        at++;
+        skipSpace();
+        const attribute = token();
+        if (attribute === null || text[at] !== "=")
+            break;
+        at++;
+        const value = quoted() ?? token();
+        if (value === null)
+            break;
+        parameters.push({
+            attribute: attribute.toLowerCase(),
+            originalAttribute: attribute,
+            value,
+        });
+        skipSpace();
+    }
+    return made(subtype);
+}
+/** `needle` を `from` から探す。無ければ -1 */
+function find(haystack, needle, from) {
+    const first = needle[0];
+    for (let at = haystack.indexOf(first, from); at !== -1; at = haystack.indexOf(first, at + 1)) {
+        if (at + needle.length > haystack.length)
+            return -1;
+        let same = true;
+        for (let k = 1; k < needle.length; k++) {
+            if (haystack[at + k] !== needle[k]) {
+                same = false;
+                break;
+            }
+        }
+        if (same)
+            return at;
+    }
+    return -1;
+}
+/**
+ * 中身を1つ読む。**ヘッダの終わり (空行) が無いものは null** — どこからが本体か
+ * 分からない。`multipart/mixed` なら中までデコードする (入れ子も同じ形)。
+ *
+ * @param part multipart の中の部品か。部品はヘッダの行でちょうど終わってよい (下の説明)
+ */
+export function readEntity(data, part = false) {
+    const headers = [];
+    let at = 0;
+    for (;;) {
+        // 中身が空の部品は、ヘッダの空行の CRLF が次の区切りの頭に食われて、ヘッダの行で
+        // ちょうど終わる (`--X\r\nContent-Type: a\r\n\r\n--X--`)。空の本体として受ける
+        // (web-bml の entity-parser はここで null を返し、モジュールごと捨てていた)
+        if (part && at === data.length && headers.length > 0)
+            break;
+        const end = find(data, CRLF, at);
+        if (end === -1)
+            return null;
+        if (end === at) {
+            at += 2;
+            break;
+        }
+        const line = utf8.decode(data.subarray(at, end));
+        at = end + 2;
+        // 行頭が空白なら前の行の続き (折り返し)
+        if ((line[0] === " " || line[0] === "\t") && headers.length > 0) {
+            const last = headers[headers.length - 1];
+            last.value = `${last.value} ${line.trim()}`;
+            continue;
+        }
+        const colon = line.indexOf(":");
+        if (colon <= 0)
+            return null;
+        headers.push({
+            name: line.slice(0, colon).trim().toLowerCase(),
+            value: line.slice(colon + 1).trim(),
+        });
+    }
+    const body = data.subarray(at);
+    const type = headers.find((header) => header.name === "content-type");
+    const media = type === undefined ? null : parseMediaType(type.value);
+    let parts = null;
+    if (media?.type === "multipart" && media.subtype === "mixed") {
+        const boundary = media.parameters.find((parameter) => parameter.attribute === "boundary")?.value;
+        parts = boundary === undefined ? null : splitParts(body, boundary);
+    }
+    return { headers, body, parts };
+}
+/**
+ * 区切りで切る。**閉じの区切り (`--XXX--`) まで揃っていないものは捨てる** —
+ * 最後の1つがどこで終わるか分からない
+ */
+function splitParts(body, boundary) {
+    const open = encoder.encode(`--${boundary}\r\n`);
+    const next = encoder.encode(`\r\n--${boundary}`);
+    let at = find(body, open, 0);
+    if (at === -1)
+        return null;
+    at += open.length;
+    const parts = [];
+    for (let from = at;;) {
+        const end = find(body, next, from);
+        if (end === -1)
+            return null;
+        const after = end + next.length;
+        // `--` が続けば閉じ、CRLF なら次の1つ。どちらでもなければ本体の中の似た並び
+        const close = body[after] === 0x2d && body[after + 1] === 0x2d;
+        if (!close && (body[after] !== CR || body[after + 1] !== LF)) {
+            from = end + 1;
+            continue;
+        }
+        const part = readEntity(body.subarray(at, end), true);
+        if (part === null)
+            return null;
+        parts.push(part);
+        if (close)
+            return parts;
+        at = after + 2;
+        from = at;
+    }
+}

package/dist/pes.d.ts

@@ -0,0 +1,99 @@
+/**
+ * **1局に絞った TS から、映像と音声の PES を取り出す** (ライブを変換せずに送る経路。docs/stream.md#放送そのままmpeg-2を送る)。
+ *
+ * エンコードする経路ではここを ffmpeg がやっていた。変換せずに送ると TS がそのままブラウザへ来るので、
+ * 映像も音声も WASM のデコーダ (`wasm/decoder.c`) に渡す前に、
+ * こちらで PES に戻す。サーバが1局に絞ってある (`ServiceFilter`) ので、PAT に
+ * 載っている局は1つだけ — その PMT を読んで、映像1本と音声 (並んだ順) を取り出す。
+ *
+ * DOM も WASM も触らないので、ここだけ単体で確かめられる (`pes.test.ts`)。
+ */
+/** PTS・PCR の刻み (90kHz)。取り決めの時刻もこの刻み (docs/stream.md#websocket-プロトコル) */
+export declare const CLOCK = 90000;
+/** PTS の一周 (33ビット)。26.5 時間 */
+export declare const WRAP: number;
+export interface Pes {
+    pid: number;
+    kind: "video" | "audio";
+    /** 90kHz。無ければ null */
+    pts: number | null;
+    /** 90kHz。PTS と同じなら書かれないので、そのときは PTS を入れる */
+    dts: number | null;
+    /** PES の中身 (ES) */
+    data: Uint8Array;
+}
+/** PMT から分かったこと。**音声は並んだ順** — 画面の「何本目の音声」(`AudioTrack.stream`) と揃う */
+export interface Streams {
+    video: number | null;
+    audio: number[];
+}
+/** 5バイトの PTS / DTS を読む (ISO/IEC 13818-1 2.4.3.7) */
+export declare function readStamp(data: Uint8Array, at: number): number;
+/** PES の頭を読んで中身を切り出す。**壊れていれば null** (頭の 00 00 01 が無いなど) */
+export declare function parsePes(data: Uint8Array): {
+    pts: number | null;
+    dts: number | null;
+    data: Uint8Array;
+} | null;
+/**
+ * TS を食わせて PES を吐く。**選局し直したら作り直す** (前の局の切れ端を持ち越さない)。
+ *
+ * 映像は長さ 0 (次の頭で終わりが分かる) なので1枚ぶん遅れて出るが、貯めの中に収まる。
+ * 音声は長さが書いてあるので揃った時点で出す
+ */
+export declare class PesDemuxer {
+    private readonly packets;
+    /** 絞ってあるので局は1つだけのはず。万一複数あっても先頭を採る */
+    private readonly pmt;
+    private readonly partial;
+    /** いま分かっている ES。**変わったら `feed` の返りで知らせる** */
+    streams: Streams;
+    /** デコードする音声の PID。**選ばれた1本だけ**組み立てる (他は捨てる) */
+    audioPid: number | null;
+    /** 何本目の音声を取り出すか (`AudioTrack.stream`)。無ければ先頭に落とす */
+    audioIndex: number;
+    feed(chunk: Uint8Array): {
+        pes: Pes[];
+        changed: boolean;
+    };
+    /** 音声を選び直す。**組み立てかけのものは捨てる** (前の音声の続きになる) */
+    selectAudio(index: number): void;
+    private readPmt;
+    private collect;
+    private finish;
+}
+/** ADTS の標本化周波数の表 (ISO/IEC 14496-3 表 1.18) */
+export declare const ADTS_RATES: number[];
+export interface AdtsFrame {
+    /** 頭 (7 か 9 バイト) ごと。WASM の AAC デコーダは ADTS のまま受け取る */
+    data: Uint8Array;
+    /** 90kHz */
+    pts: number;
+    sampleRate: number;
+    channels: number;
+    /** このコマの長さ (90kHz)。AAC は1コマ 1024 標本 */
+    duration: number;
+}
+/**
+ * PES の中身を ADTS のコマに割る。**コマは PES をまたぐことがある**ので、余りは持ち越す。
+ *
+ * 時刻は PES の PTS を頭のコマに付け、続くコマには1コマぶんずつ足す。持ち越した
+ * 余りから始まるコマは、前の続きの時刻になる
+ */
+export declare class AdtsSplitter {
+    private rest;
+    private next;
+    feed(data: Uint8Array, pts: number | null): AdtsFrame[];
+    reset(): void;
+}
+/**
+ * **33ビットで一周する時刻を、手元の物差しの近くへ伸ばす。**
+ *
+ * PTS は 26.5 時間で 0 に戻る。受け側は「いま鳴らしている時刻」を一周をまたいでも
+ * 増え続ける数で持つので、届いた時刻は**それにいちばん近い周**に置き直して比べる
+ * (字幕・時計の通知・次の PES)
+ *
+ * @param pts 届いた時刻 (90kHz。一周の中)
+ * @param near 手元の物差し (90kHz。伸ばしたもの)
+ */
+export declare function unwrap(pts: number, near: number): number;

package/dist/pes.js

@@ -0,0 +1,231 @@
+/**
+ * **1局に絞った TS から、映像と音声の PES を取り出す** (ライブを変換せずに送る経路。docs/stream.md#放送そのままmpeg-2を送る)。
+ *
+ * エンコードする経路ではここを ffmpeg がやっていた。変換せずに送ると TS がそのままブラウザへ来るので、
+ * 映像も音声も WASM のデコーダ (`wasm/decoder.c`) に渡す前に、
+ * こちらで PES に戻す。サーバが1局に絞ってある (`ServiceFilter`) ので、PAT に
+ * 載っている局は1つだけ — その PMT を読んで、映像1本と音声 (並んだ順) を取り出す。
+ *
+ * DOM も WASM も触らないので、ここだけ単体で確かめられる (`pes.test.ts`)。
+ */
+import { concatBytes, u16 } from "./bytes.js";
+import { PACKET, packetPid, PacketStream, PID_PAT, pmtStreams, PmtTracker, } from "./psi.js";
+/** PTS・PCR の刻み (90kHz)。取り決めの時刻もこの刻み (docs/stream.md#websocket-プロトコル) */
+export const CLOCK = 90_000;
+/** PTS の一周 (33ビット)。26.5 時間 */
+export const WRAP = 2 ** 33;
+/** PMT の stream_type。**放送の映像は MPEG-2、音声は ADTS の AAC** (ARIB STD-B32) */
+const STREAM_MPEG2 = 0x02;
+const STREAM_AAC = 0x0f;
+/** 5バイトの PTS / DTS を読む (ISO/IEC 13818-1 2.4.3.7) */
+export function readStamp(data, at) {
+    return (((data[at] >> 1) & 0x07) * 2 ** 30 +
+        (data[at + 1] << 22) +
+        ((data[at + 2] >> 1) << 15) +
+        (data[at + 3] << 7) +
+        (data[at + 4] >> 1));
+}
+/** PES の頭を読んで中身を切り出す。**壊れていれば null** (頭の 00 00 01 が無いなど) */
+export function parsePes(data) {
+    if (data.length < 9 || data[0] !== 0 || data[1] !== 0 || data[2] !== 1)
+        return null;
+    const flags = data[7] >> 6;
+    const headerLength = data[8];
+    const start = 9 + headerLength;
+    if (start > data.length)
+        return null;
+    const length = u16(data, 4);
+    // 長さが書いてあればそこまで (後ろに詰め物が付くことがある)。0 は「次の頭まで」
+    const end = length === 0 ? data.length : Math.min(data.length, 6 + length);
+    const pts = flags & 0x02 && data.length >= 14 ? readStamp(data, 9) : null;
+    const dts = flags === 0x03 && data.length >= 19 ? readStamp(data, 14) : pts;
+    return { pts, dts, data: data.subarray(start, end) };
+}
+/**
+ * TS を食わせて PES を吐く。**選局し直したら作り直す** (前の局の切れ端を持ち越さない)。
+ *
+ * 映像は長さ 0 (次の頭で終わりが分かる) なので1枚ぶん遅れて出るが、貯めの中に収まる。
+ * 音声は長さが書いてあるので揃った時点で出す
+ */
+export class PesDemuxer {
+    packets = new PacketStream();
+    /** 絞ってあるので局は1つだけのはず。万一複数あっても先頭を採る */
+    pmt = new PmtTracker();
+    partial = new Map();
+    /** いま分かっている ES。**変わったら `feed` の返りで知らせる** */
+    streams = { video: null, audio: [] };
+    /** デコードする音声の PID。**選ばれた1本だけ**組み立てる (他は捨てる) */
+    audioPid = null;
+    /** 何本目の音声を取り出すか (`AudioTrack.stream`)。無ければ先頭に落とす */
+    audioIndex = 0;
+    feed(chunk) {
+        const out = [];
+        let changed = false;
+        for (const packet of this.packets.feed(chunk)) {
+            // 誤りの印が立っているもの・スクランブルが残っているものは読まない
+            if (packet[1] & 0x80 || packet[3] & 0xc0)
+                continue;
+            const pid = packetPid(packet);
+            if (pid === PID_PAT || pid === this.pmt.pid) {
+                for (const section of this.pmt.feed(packet, pid))
+                    changed = this.readPmt(section) || changed;
+                continue;
+            }
+            if (pid === this.streams.video)
+                this.collect(packet, pid, "video", out);
+            else if (pid === this.audioPid)
+                this.collect(packet, pid, "audio", out);
+        }
+        return { pes: out, changed };
+    }
+    /** 音声を選び直す。**組み立てかけのものは捨てる** (前の音声の続きになる) */
+    selectAudio(index) {
+        this.audioIndex = index;
+        const next = this.streams.audio[index] ?? this.streams.audio[0] ?? null;
+        if (next !== this.audioPid && this.audioPid !== null)
+            this.partial.delete(this.audioPid);
+        this.audioPid = next;
+    }
+    readPmt(section) {
+        let video = null;
+        const audio = [];
+        for (const [type, pid] of pmtStreams(section)) {
+            if (type === STREAM_MPEG2 && video === null)
+                video = pid;
+            else if (type === STREAM_AAC)
+                audio.push(pid);
+        }
+        const same = video === this.streams.video &&
+            audio.length === this.streams.audio.length &&
+            audio.every((pid, i) => pid === this.streams.audio[i]);
+        if (same)
+            return false;
+        this.streams = { video, audio };
+        this.partial.clear();
+        this.selectAudio(this.audioIndex);
+        return true;
+    }
+    collect(packet, pid, kind, out) {
+        const control = (packet[3] >> 4) & 0x03;
+        if (control === 0 || control === 2)
+            return;
+        let offset = 4;
+        if (control === 3)
+            offset += 1 + packet[4];
+        if (offset >= PACKET)
+            return;
+        const payload = packet.subarray(offset);
+        if (packet[1] & 0x40) {
+            // 次の頭が来た。**長さ 0 の PES (映像) はここで終わりが分かる**
+            this.finish(pid, kind, out);
+            const expected = payload.length >= 6 ? 6 + u16(payload, 4) : 0;
+            // 溜めるものは写す。パケットは届いた塊の上の窓で、塊は使い回される (psi.ts の PacketStream)
+            this.partial.set(pid, {
+                parts: [payload.slice()],
+                size: payload.length,
+                expected: expected === 6 ? 0 : expected,
+            });
+        }
+        else {
+            const partial = this.partial.get(pid);
+            // 頭を見ていない続きは捨てる (途中から受け取った)
+            if (partial === undefined)
+                return;
+            partial.parts.push(payload.slice());
+            partial.size += payload.length;
+        }
+        const partial = this.partial.get(pid);
+        if (partial !== undefined &&
+            partial.expected > 0 &&
+            partial.size >= partial.expected) {
+            this.finish(pid, kind, out);
+        }
+    }
+    finish(pid, kind, out) {
+        const partial = this.partial.get(pid);
+        if (partial === undefined)
+            return;
+        this.partial.delete(pid);
+        const parsed = parsePes(concatBytes(partial.parts));
+        if (parsed === null || parsed.data.length === 0)
+            return;
+        out.push({ pid, kind, ...parsed });
+    }
+}
+/** ADTS の標本化周波数の表 (ISO/IEC 14496-3 表 1.18) */
+export const ADTS_RATES = [
+    96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025,
+    8000, 7350,
+];
+/**
+ * PES の中身を ADTS のコマに割る。**コマは PES をまたぐことがある**ので、余りは持ち越す。
+ *
+ * 時刻は PES の PTS を頭のコマに付け、続くコマには1コマぶんずつ足す。持ち越した
+ * 余りから始まるコマは、前の続きの時刻になる
+ */
+export class AdtsSplitter {
+    rest = new Uint8Array(0);
+    next = null;
+    feed(data, pts) {
+        // 余りが無いときだけ PES の時刻に合わせ直す (余りがあれば頭のコマはその続き)
+        if (pts !== null && this.rest.length === 0)
+            this.next = pts;
+        const buffer = this.rest.length === 0 ? data : concatBytes([this.rest, data]);
+        const out = [];
+        let at = 0;
+        while (at + 7 <= buffer.length) {
+            if (buffer[at] !== 0xff || (buffer[at + 1] & 0xf6) !== 0xf0) {
+                at++;
+                continue;
+            }
+            const length = ((buffer[at + 3] & 0x03) << 11) |
+                (buffer[at + 4] << 3) |
+                (buffer[at + 5] >> 5);
+            if (length < 7) {
+                at++;
+                continue;
+            }
+            if (at + length > buffer.length)
+                break;
+            const rate = ADTS_RATES[(buffer[at + 2] >> 2) & 0x0f] ?? 48000;
+            const channels = ((buffer[at + 2] & 0x01) << 2) | (buffer[at + 3] >> 6);
+            const duration = Math.round((1024 * CLOCK) / rate);
+            if (this.next !== null) {
+                out.push({
+                    data: buffer.slice(at, at + length),
+                    pts: this.next,
+                    sampleRate: rate,
+                    // 0 は「中身に書いてある」(PCE)。放送のデュアルモノはここに来るので、2本とみなす
+                    channels: channels === 0 ? 2 : channels,
+                    duration,
+                });
+                this.next += duration;
+            }
+            at += length;
+        }
+        this.rest = buffer.slice(at);
+        // 同期が取れないまま溜め込まない
+        if (this.rest.length > 8192)
+            this.rest = new Uint8Array(0);
+        if (pts !== null && this.rest.length === 0 && out.length === 0)
+            this.next = pts;
+        return out;
+    }
+    reset() {
+        this.rest = new Uint8Array(0);
+        this.next = null;
+    }
+}
+/**
+ * **33ビットで一周する時刻を、手元の物差しの近くへ伸ばす。**
+ *
+ * PTS は 26.5 時間で 0 に戻る。受け側は「いま鳴らしている時刻」を一周をまたいでも
+ * 増え続ける数で持つので、届いた時刻は**それにいちばん近い周**に置き直して比べる
+ * (字幕・時計の通知・次の PES)
+ *
+ * @param pts 届いた時刻 (90kHz。一周の中)
+ * @param near 手元の物差し (90kHz。伸ばしたもの)
+ */
+export function unwrap(pts, near) {
+    return pts + Math.round((near - pts) / WRAP) * WRAP;
+}