@torrent-tv/proxy 2.95.13 → 2.95.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.95.13",
+  "version": "2.95.14",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/routes/encode-input/get.js

@@ -19,9 +19,12 @@ export function handleEncodeInputGet(req, reply, { inputOf }) {
   }
   const range = parseRange(req.headers.range, length);
   if (!range || range.start >= length) return reply.code(416).header("Content-Range", `bytes */${length}`).send();
-  // Older FFmpeg versions request through EOF. A finite partial response keeps
-  // each read within the admitted lookahead, without version-specific options.
-  range.end = Math.min(range.end, range.start + 1048575);
+  // The answer runs to the end of the admitted range the read starts in, which
+  // is what keeps FFmpeg inside the bytes the run holds. A shorter answer is
+  // not continued by every FFmpeg: 6.1 (ffmpeg-static) takes it for the end of
+  // the input and stops, where 8.1 sends a new request (http.c, EAGAIN at the
+  // end of a content range). A cap of 1 MiB here ended every original-source
+  // segment longer than that on 6.1 (torrent-tv/meta#151).
   const held = input.read(fileIndex, range.start, range.end, true);
   if (!held) return reply.code(503).send({ error: "Original input bytes are outside the admitted ranges." });
   return reply.code(206).header("Content-Length", String(held.bytes.length))

package/server.js

@@ -561,6 +561,7 @@ export async function startProxyServer({
       return {
         times: index?.times ?? null,
         tolerance: index?.tolerance ?? 0,
+        copyable: index?.copyable,
         // Which container answered, whether or not it produced a table: the
         // refusal that follows names it, and a measurement of how often an
         // index disagrees with its own file cannot be read without it.
@@ -596,14 +597,19 @@ export async function startProxyServer({
           mode: type === "video" ? spec.encode ? "transcode" : "copy" : spec.transcode ? "transcode" : "copy" });
         selected.set(spec.fileIndex, list);
       }
-      const sources = [];
+      // Every selected file is read the same way in one run: from the original
+      // file when each container can name the bytes the interval needs, from
+      // reassembled packets otherwise.
+      const files = [];
       for (const [fileIndex, choices] of selected) {
         const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
         if (!params) return { kind: "needs-source" };
         const tracks = await containerOrchestrator.inspect(params, "tracks");
         if (tracks.kind !== "result") return tracks;
         const container = containerOrchestrator.known(params.sourceKey, fileIndex);
-        if (typeof container?.readPacketIndex !== "function") return { kind: "needs-index", reason: "packet-index-not-yet-available" };
+        if (typeof container?.readPacketIndex !== "function" && typeof container?.readSourceRanges !== "function") {
+          return { kind: "needs-index", reason: "packet-index-not-yet-available" };
+        }
         const modes = new Map(), wanted = [];
         for (const choice of choices) {
           // The picture is the first usable video track (torrent-tv/meta#49);
@@ -622,7 +628,12 @@ export async function startProxyServer({
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
         const navigation = await containerOrchestrator.inspect(params, "source-navigation");
         if (navigation.kind !== "result") return navigation;
-        if (navigation.value && selected.size === 1 && output.segmentFormat.supportsOriginalInput === true) {
+        files.push({ fileIndex, choices, params, wanted, modes, timeShiftSeconds, sourceInterval, navigable: navigation.value === true });
+      }
+      const original = output.segmentFormat.supportsOriginalInput === true && files.every(file => file.navigable);
+      const sources = [];
+      for (const { fileIndex, choices, params, wanted, modes, timeShiftSeconds, sourceInterval } of files) {
+        if (original) {
           const ranges = await containerOrchestrator.inspect(params, "source-ranges");
           if (ranges.kind !== "result") return ranges;
           sources.push({ sourceKey: params.sourceKey, fileIndex, timeShiftSeconds,

package/services/encode/OutputOpening.js

@@ -468,6 +468,16 @@ export class OutputOpening {
               "re-encoded instead and its keyframes are placed on our own cuts"
           );
         }
+      } else if (!keyframes.copyable) {
+        // The container states when each picture is decoded and not when it is
+        // shown, and this picture may show them in another order: a copy would
+        // carry the decoding times and play its pictures out of order. A
+        // re-encode decodes them in their own order and stamps them itself.
+        transcodeVideo = true;
+        this.#host.logger.warn(
+          `transcode: the ${keyframes.format} container states no presentation times for "${logName}" and its ` +
+            "picture may reorder, so a copy would play out of order — the video is re-encoded instead"
+        );
       }
     }
     this.#host.logger.info(

package/services/media/KeyframeTables.js

@@ -107,6 +107,7 @@ export class KeyframeTables {
         table.learn({
           times: Array.isArray(reading?.times) ? reading.times : null,
           tolerance: reading?.tolerance,
+          copyable: reading?.copyable,
           // Which container answered, whether or not it produced a table: the
           // refusal that follows names it, and "unknown" would make that line
           // say nothing about the file it is refusing.

package/services/media/container/AviContainer.js

@@ -1,7 +1,10 @@
 /**
  * @file AVI container — RIFF.
  *
- * Stream declarations and exact packet addresses from idx1 or OpenDML indexes.
+ * Stream declarations, and from the index alone (`idx1` or OpenDML) the
+ * keyframes and the original bytes a run needs: FFmpeg reads an indexed AVI
+ * from the file itself (`avi-index.js`, torrent-tv/meta#151). Packets are
+ * reassembled only for an AVI that states no index.
  */
 
 import { Container } from "./Container.js";
@@ -9,15 +12,16 @@ import { VideoTrack } from "../tracks/VideoTrack.js";
 import { AudioTrack } from "../tracks/AudioTrack.js";
 import { ContainerTrack } from "../tracks/ContainerTrack.js";
 import { PacketIndex } from "./PacketIndex.js";
-import { openDmlPackets } from "./avi-open-dml.js";
+import { readAviIndex } from "./avi-index.js";
 import { isUnavailable } from "./unavailable.js";
-import { IndexMemoryUnavailable } from "./memory-unavailable.js";
 import { Mpeg4PictureTiming } from "./mpeg4-picture-timing.js";
 import { MpegElementaryIndex } from "./mpeg-elementary-index.js";
 import { RetainedReads } from "./RetainedReads.js";
 import { OutsideReadableEdges, edgeReader, emptyWorkTags, text, textList, yearOf } from "./work-tags.js";
 
 const MPEG4_CODECS = new Set(["FMP4", "XVID", "DIVX", "DX50", "MP4V", "M4S2", "MP4S"]);
+/** Picture codecs whose every picture stands alone, so decoding order is showing order. */
+const INTRA_PICTURE_CODECS = new Set(["MJPG", "JPEG", "DIB ", "\0\0\0\0", "I420", "YV12", "YUY2", "UYVY"]);
 const MPEG_AUDIO_CODECS = new Set(["mp1", "mp2", "mp3"]);
 const NAL_CODECS = new Map([["H264", "h264"], ["X264", "h264"], ["AVC1", "h264"], ["HEVC", "hevc"], ["H265", "hevc"]]);
 
@@ -26,9 +30,11 @@ export class AviContainer extends Container {
   #tracks = null;
   #packets = null;
   #scan = null;
-  #indexed = null;
   #declarations = null;
   #workTags = null;
+  /** The index alone: undefined until read, null when the file states none. */
+  #index = undefined;
+  #layout = null;
 
   async #readHeaders() {
     if (this.#headers) return this.#headers;
@@ -110,24 +116,83 @@ export class AviContainer extends Container {
   }
 
 
-  packetIndexBytes() { return (this.#packets ?? this.#scan?.index ?? this.#indexed?.index)?.allocatedBytes() ?? 0; }
+  /** The first RIFF's `movi` list and `idx1` chunk. */
+  async #topLevel() {
+    if (this.#layout) return this.#layout;
+    const header = await this.readRange(0, 11);
+    const chunks = await riffChunks(this.readRange, 12, 8 + header.readUInt32LE(4));
+    const movi = chunks.find(chunk => chunk.id === "LIST" && chunk.type === "movi");
+    if (!movi) throw new Error("AVI media list is absent.");
+    this.#layout = { movi, idx1: chunks.find(chunk => chunk.id === "idx1") ?? null };
+    return this.#layout;
+  }
 
-  static detect(head) {
-    return isAvi(head);
+  /**
+   * What the index states, read once; null when the file states no index.
+   * A shortage of bytes or memory is thrown and nothing is kept, so the next
+   * read starts again from the index (the index is small and read in requests).
+   */
+  async #readIndex() {
+    if (this.#index !== undefined) return this.#index;
+    const tracks = await this.readTracks();
+    const { streams } = await this.#readHeaders();
+    const { movi, idx1 } = await this.#topLevel();
+    const record = { dispose: () => this.#index?.dispose?.() };
+    const allocation = this.packetMemory?.forRecord?.(record, "index") ?? this.packetMemory;
+    const index = await readAviIndex({ read: this.readRange, fileSize: this.fileSize, movi, idx1, allocation,
+      streams: tracks.map(track => ({ type: track.type, timeBase: track.timeBase, sampleSize: track.sampleSize,
+        startTimeSeconds: track.startTimeSeconds, indexChunks: streams[track.trackNumber].indexChunks })) });
+    this.#index = index;
+    return index;
   }
 
+  async supportsOriginalSourceRanges() {
+    const index = await this.#readIndex();
+    if (!index) return false;
+    const picture = ContainerTrack.firstUsable(await this.readTracks(), "video");
+    return !picture || index.keyframeTimes(picture.trackNumber).length > 0;
+  }
+
+  async readMappedSourceRanges(interval) { return this.readSourceRanges(interval); }
+
   /**
-   * The keyframe times this container's own index states, in ascending seconds.
-   *
-   * Static so a caller that has bytes and no container can ask; the instance
-   * form is {@link Container#readKeyframeIndex}.
-   *
-   * @param {(start:number,end:number)=>Promise<Buffer|null>} readRange
-   * @param {number} fileSize
-   * @returns {Promise<number[]|null>} Null where the container has no index.
+   * The bytes FFmpeg reads to produce `[from, to)` from the original file:
+   * the declarations and the start of `movi` it probes, the index it loads at
+   * open (`idx1` to the end of the file, or every OpenDML standard index), the
+   * first packet of each stream it inspects, and the selected streams' packets
+   * around the interval. Each range is held one MiB past its last named byte,
+   * because FFmpeg's input buffer reads ahead of the packet it is parsing.
    */
-  static readKeyframeTimes(readRange, fileSize) {
-    return readAviKeyframeTimes(readRange, fileSize);
+  async readSourceRanges(interval) {
+    if (!Number.isFinite(interval?.from) || !Number.isFinite(interval?.to) || interval.to <= interval.from) {
+      throw new TypeError("Source ranges require a finite increasing interval.");
+    }
+    const index = await this.#readIndex();
+    if (!index) return { kind: "needs-index", reason: "source-has-no-avi-index" };
+    const tracks = await this.readTracks();
+    const { movi } = await this.#topLevel();
+    const requested = tracks.filter(track => ["video", "audio"].includes(track.type) &&
+      (!interval.trackIds?.length || interval.trackIds.includes(track.trackNumber)));
+    const picture = ContainerTrack.firstUsable(tracks, "video");
+    const requestBytes = 1024 * 1024;
+    const padded = ([start, end]) => [Math.max(0, start), Math.min(this.fileSize - 1, end + requestBytes)];
+    const ranges = [[0, movi.start + 3], ...index.indexRanges, ...index.firstPackets(),
+      ...index.mediaRanges({ from: interval.from, to: interval.to, picture: picture?.trackNumber ?? null,
+        streams: requested.map(track => track.trackNumber) })].map(padded);
+    ranges.sort((left, right) => left[0] - right[0]);
+    const union = [];
+    for (const range of ranges) {
+      const previous = union.at(-1);
+      if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
+      else union.push([...range]);
+    }
+    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize };
+  }
+
+  packetIndexBytes() { return (this.#packets ?? this.#scan?.index)?.allocatedBytes() ?? 0; }
+
+  static detect(head) {
+    return isAvi(head);
   }
 
   async readTracks() {
@@ -206,152 +271,46 @@ export class AviContainer extends Container {
   }
 
   async parseKeyframeIndex() {
-    const { streams } = await this.#readHeaders();
-    const picture = (await this.readTracks()).find(track => track.type === "video");
-    if (streams.some(stream => stream.indexChunks.length) || ["h264", "hevc"].includes(picture?.codecId) || MPEG4_CODECS.has(picture?.codecId.toUpperCase())) {
-      const index = await this.readPacketIndex();
-      return picture ? { times: index.keyframesOf(picture.trackNumber), tolerance: 0 } : null;
-    }
-    const r = await readAviKeyframeTimes(this.readRange, this.fileSize);
-    if (!r) {
-      return picture ? { times: (await this.readPacketIndex()).keyframesOf(picture.trackNumber), tolerance: 0 } : null;
-    }
-    if (Array.isArray(r)) return { times: r, tolerance: 0 };
-    return r;
+    const picture = ContainerTrack.firstUsable(await this.readTracks(), "video");
+    if (!picture) return null;
+    // The index states every keyframe on the clock FFmpeg reads the file by,
+    // so no packet is read to learn them (torrent-tv/meta#151). A file with no
+    // index has its packets scanned instead.
+    // AVI states no presentation time, only each packet's place in decoding
+    // order. A picture whose codec may show its pictures in another order
+    // (B-pictures) is therefore not copied: FFmpeg stamps a copy with the
+    // decoding times and the pictures lose their order — measured on an H.264
+    // AVI with B-pictures, where a whole-file copy to MP4 decodes to other
+    // pictures than the source. Reading the order from the bitstream is the
+    // parsing the original-file path exists to avoid (torrent-tv/meta#151).
+    const copyable = INTRA_PICTURE_CODECS.has(picture.codecId.toUpperCase());
+    const index = await this.#readIndex();
+    if (index) return { times: index.keyframeTimes(picture.trackNumber), tolerance: 0, copyable };
+    return { times: (await this.readPacketIndex()).keyframesOf(picture.trackNumber), tolerance: 0, copyable };
   }
 
   async readPacketIndex(interval) {
     if (this.#packets) return this.#packets;
     if (this.#scan) return this.#readUnindexed(interval);
-    if (this.#indexed) return this.#readIndexed();
+    // A file with an index is read by FFmpeg from the original bytes; packets
+    // are reassembled only where no index states them (torrent-tv/meta#151).
+    if (await this.#readIndex()) throw new Error("AVI with an index is read from the original file, not from reassembled packets.");
     const tracks = await this.readTracks();
     const { streams } = await this.#readHeaders();
-    if (streams.some(stream => stream.indexChunks.length)) {
-      const index = new PacketIndex({ packetMemory: this.packetMemory, deferMemory: true });
-      const timings = new Map();
-      try {
-      for (const track of tracks.filter(track => ["video", "audio"].includes(track.type))) {
-        if (!(track.timeBase > 0) || !streams[track.trackNumber].indexChunks.length) throw new Error("AVI OpenDML stream index is incomplete.");
-        index.declareTrack(track.trackNumber, { type: track.type, codecId: track.codecId, codecRanges: streams[track.trackNumber].codecRanges });
-        let pts = track.startTimeSeconds;
-        for await (const packet of openDmlPackets({ readRange: this.readRange, fileSize: this.fileSize,
-          indexes: streams[track.trackNumber].indexChunks, streamId: track.trackNumber })) {
-          if (!packet.length) {
-            if (track.type === "video") { index.extendLastPresentation(track.trackNumber, track.timeBase); pts += track.timeBase; }
-            continue;
-          }
-          if (track.sampleSize > 0 && packet.length % track.sampleSize) throw new Error("AVI packet contains an incomplete fixed-size sample.");
-          const duration = track.timeBase * (track.sampleSize > 0 ? packet.length / track.sampleSize : 1);
-          await this.#appendPacket(index, timings, track, { pts, duration, keyframe: track.type !== "video" || packet.keyframe,
-            ranges: [[packet.start, packet.start + packet.length - 1]] });
-          pts += duration;
-          index.flushPending();
-        }
-        timings.get(track.trackNumber)?.elementary?.complete();
-        index.flushPending();
-        index.complete(track.trackNumber);
-      }
-      this.#packets = index;
-      return index;
-      } catch (error) {
-        index.dispose();
-        throw error;
-      }
-    }
-    const header = await this.readRange(0, 11);
-    const chunks = await riffChunks(this.readRange, 12, 8 + header.readUInt32LE(4));
-    const movi = chunks.find(chunk => chunk.id === "LIST" && chunk.type === "movi");
-    const table = chunks.find(chunk => chunk.id === "idx1");
-    if (!movi) throw new Error("AVI media list is absent.");
-    if (!table) {
-      const index = new PacketIndex({ packetMemory: this.packetMemory, deferMemory: true });
-      const clocks = new Map();
-      for (const track of tracks.filter(track => ["video", "audio"].includes(track.type))) {
-        if (!(track.timeBase > 0)) throw new Error("AVI stream time base is invalid.");
-        if (track.type === "video" && !["h264", "hevc"].includes(track.codecId) && !MPEG4_CODECS.has(track.codecId.toUpperCase()) && !["MJPG", "JPEG", "DIB ", "\0\0\0\0"].includes(track.codecId.toUpperCase())) {
-          throw new Error("AVI video without an index requires elementary picture timing.");
-        }
-        if (track.type === "audio" && !(track.sampleSize > 0) && !MPEG_AUDIO_CODECS.has(track.codecId)) throw new Error("AVI variable-size audio requires elementary frame timing.");
-        index.declareTrack(track.trackNumber, { type: track.type, codecId: track.codecId, codecRanges: streams[track.trackNumber].codecRanges });
-        clocks.set(track.trackNumber, track.startTimeSeconds);
-      }
-      this.#scan = { index, tracks, clocks, timings: new Map(), at: 0,
-        stack: [{ end: this.fileSize, next: this.fileSize }] };
-      return this.#readUnindexed(interval);
-    }
-    if ((table.end - table.start) % 16 !== 0) throw new Error("AVI packet index entry is truncated.");
     const index = new PacketIndex({ packetMemory: this.packetMemory, deferMemory: true });
     const clocks = new Map();
-    const timings = new Map();
-    if (tracks.some(track => ["video", "audio", "subtitle"].includes(track.type) && !(track.timeBase > 0))) {
-      throw new Error("AVI stream time base is invalid.");
-    }
-    for (const track of tracks) {
-      if (!["video", "audio", "subtitle"].includes(track.type)) continue;
+    for (const track of tracks.filter(track => ["video", "audio"].includes(track.type))) {
+      if (!(track.timeBase > 0)) throw new Error("AVI stream time base is invalid.");
+      if (track.type === "video" && !["h264", "hevc"].includes(track.codecId) && !MPEG4_CODECS.has(track.codecId.toUpperCase()) && !INTRA_PICTURE_CODECS.has(track.codecId.toUpperCase())) {
+        throw new Error("AVI video without an index requires elementary picture timing.");
+      }
+      if (track.type === "audio" && !(track.sampleSize > 0) && !MPEG_AUDIO_CODECS.has(track.codecId)) throw new Error("AVI variable-size audio requires elementary frame timing.");
       index.declareTrack(track.trackNumber, { type: track.type, codecId: track.codecId, codecRanges: streams[track.trackNumber].codecRanges });
       clocks.set(track.trackNumber, track.startTimeSeconds);
     }
-    this.#indexed = { index, clocks, timings, tracks, movi, table, offsetBase: null, at: table.start };
-    return this.#readIndexed();
-  }
-
-  async #readIndexed() {
-    const state = this.#indexed;
-    const { index, clocks, timings, tracks, movi, table } = state;
-    try {
-    index.flushPending();
-    for (; state.at < table.end;) {
-      const at = state.at;
-      const entry = await this.readRange(at, at + 15);
-      const chunkId = entry.toString("ascii", 0, 4);
-      if (!/^[0-9]{2}(db|dc|wb)$/.test(chunkId)) { state.at += 16; continue; }
-      const id = Number(chunkId.slice(0, 2));
-      const track = tracks.find(track => track.trackNumber === id);
-      if (!track || !clocks.has(id)) throw new Error("AVI packet refers to an undeclared stream.");
-      const flags = entry.readUInt32LE(4);
-      const offset = entry.readUInt32LE(8);
-      const length = entry.readUInt32LE(12);
-      if (length === 0) {
-        if (track.type === "video") { index.extendLastPresentation(id, track.timeBase); clocks.set(id, clocks.get(id) + track.timeBase); }
-        state.at += 16;
-        continue;
-      }
-      if (state.offsetBase === null) {
-        for (const base of [movi.start, 0, movi.start + 4]) {
-          const address = base + offset;
-          if (address < movi.start + 4 || address + 8 + length > movi.end) continue;
-          const probe = await this.readRange(address, address + 7);
-          if (probe.toString("ascii", 0, 4) === chunkId && probe.readUInt32LE(4) === length) { state.offsetBase = base; break; }
-        }
-        if (state.offsetBase === null) throw new Error("AVI packet index has no valid offset base.");
-      }
-      const address = state.offsetBase + offset;
-      if (address < movi.start + 4 || address + 8 + length > movi.end) throw new Error("AVI indexed packet exceeds its media list.");
-      const probe = await this.readRange(address, address + 7);
-      if (probe.toString("ascii", 0, 4) !== chunkId || probe.readUInt32LE(4) !== length) throw new Error("AVI packet index disagrees with its chunk header.");
-      if (track.sampleSize > 0 && length % track.sampleSize !== 0) throw new Error("AVI packet contains an incomplete fixed-size sample.");
-      const duration = track.timeBase * (track.sampleSize > 0 ? length / track.sampleSize : 1);
-      const pts = clocks.get(id);
-      await this.#appendPacket(index, timings, track, { pts, duration, keyframe: track.type !== "video" || chunkId.endsWith("db") || !!(flags & 0x10),
-        ranges: [[address + 8, address + 8 + length - 1]] });
-      clocks.set(id, pts + duration);
-      // The pending facts own this entry even if their allocation must wait.
-      state.at += 16;
-      index.flushPending();
-    }
-    for (const timing of timings.values()) timing.elementary?.complete();
-    index.flushPending();
-    for (const id of clocks.keys()) index.complete(id);
-    this.#packets = index;
-    this.#indexed = null;
-    return index;
-    } catch (error) {
-      if (!isUnavailable(error) && !(error instanceof IndexMemoryUnavailable)) {
-        index.dispose();
-        this.#indexed = null;
-      }
-      throw error;
-    }
+    this.#scan = { index, tracks, clocks, timings: new Map(), at: 0,
+      stack: [{ end: this.fileSize, next: this.fileSize }] };
+    return this.#readUnindexed(interval);
   }
 
   async #readUnindexed(interval) {
@@ -470,34 +429,6 @@ function waveCodec(tag) {
     [0xff, "aac"], [0x160, "wmav1"], [0x161, "wmav2"], [0x2000, "ac3"], [0x2001, "dts"]]).get(tag) ?? `wave:${tag}`;
 }
 
-// ---------------------------------------------------------------------------
-// RIFF speaking about AVI: the idx1 index and its keyframe flag.
-// Here because the class is the only way in.
-// ---------------------------------------------------------------------------
-/**
- * @file Keyframe index for AVI, read without downloading the file.
- *
- * AVI ends with an `idx1` chunk: one fixed-size entry per stream chunk, each
- * carrying a flags word whose keyframe bit says whether that chunk starts a
- * keyframe. Frame number times the video stream's frame duration gives the
- * time, so the index alone is enough — no media has to be read.
- *
- * `idx1` lives at the end of the file and the top-level chunk headers state
- * their sizes, so it is reached by stepping over headers (typically two hops:
- * `LIST hdrl`, `LIST movi`), not by scanning.
- *
- * Still relevant despite the format's age: older releases are largely XviD in
- * AVI, and those are exactly the files that get copied rather than re-encoded.
- */
-
-const HEADER_BYTES = 8;
-const PROBE_BYTES = 4096;
-// Keyframe flag in an idx1 entry's flags word (AVIIF_KEYFRAME).
-const KEYFRAME_FLAG = 0x10;
-const IDX1_ENTRY_BYTES = 16;
-// Cap on the idx1 read. One entry per chunk, 16 bytes each — a long film runs
-// to a few MB; beyond this is not a normal index.
-const MAX_IDX1_BYTES = 64 * 1024 * 1024;
 
 /**
  * Whether this looks like AVI: a RIFF container whose form type is `AVI `.
@@ -513,131 +444,5 @@ function isAvi(head) {
   );
 }
 
-/**
- * Microseconds per frame and the video stream's chunk id prefix, from the main
- * header. Both live in the `hdrl` list near the file start.
- *
- * @param {Buffer} head
- * @returns {{ microsecondsPerFrame: number } | null}
- */
-function readMainHeader(head) {
-  // Top-level: "RIFF" size "AVI " then chunks. `avih` sits inside `LIST hdrl`.
-  let offset = 12;
-  while (offset + HEADER_BYTES <= head.length) {
-    const id = head.toString("latin1", offset, offset + 4);
-    const size = head.readUInt32LE(offset + 4);
-    if (size <= 0) {
-      return null;
-    }
-    if (id === "LIST") {
-      // Descend: list type follows the header, then its own chunks.
-      const listType = head.toString("latin1", offset + 8, offset + 12);
-      if (listType === "hdrl") {
-        let inner = offset + 12;
-        while (inner + HEADER_BYTES <= Math.min(head.length, offset + 8 + size)) {
-          const innerId = head.toString("latin1", inner, inner + 4);
-          const innerSize = head.readUInt32LE(inner + 4);
-          if (innerSize <= 0) {
-            return null;
-          }
-          if (innerId === "avih" && inner + 8 + 4 <= head.length) {
-            return { microsecondsPerFrame: head.readUInt32LE(inner + 8) };
-          }
-          inner += HEADER_BYTES + innerSize + (innerSize % 2);
-        }
-      }
-      offset += HEADER_BYTES + 4 + (size - 4) + ((size - 4) % 2);
-      continue;
-    }
-    offset += HEADER_BYTES + size + (size % 2);
-  }
-  return null;
-}
 
-/**
- * Step over top-level chunks to find `idx1`.
- *
- * @param {(start: number, end: number) => Promise<Buffer | null>} readRange
- * @param {number} fileSize
- * @returns {Promise<{ offset: number, size: number } | null>}
- */
-async function findIdx1(readRange, fileSize) {
-  let offset = 12; // Past "RIFF" size "AVI ".
-  while (offset + HEADER_BYTES < fileSize) {
-    const probe = await readRange(offset, Math.min(fileSize - 1, offset + HEADER_BYTES - 1));
-    if (!probe || probe.length < HEADER_BYTES) {
-      return null;
-    }
-    const id = probe.toString("latin1", 0, 4);
-    const size = probe.readUInt32LE(4);
-    if (size <= 0) {
-      return null;
-    }
-    if (id === "idx1") {
-      return { offset: offset + HEADER_BYTES, size };
-    }
-    // Chunks are word-aligned; a LIST carries its type inside the payload, so
-    // the same size arithmetic covers both cases.
-    offset += HEADER_BYTES + size + (size % 2);
-  }
-  return null;
-}
 
-/**
- * Read the keyframe times of an AVI file.
- *
- * @param {(start: number, end: number) => Promise<Buffer | null>} readRange
- * @param {number} fileSize
- * @returns {Promise<number[] | null>} Ascending seconds, or null when the file
- *   has no `idx1` (OpenDML-only index, interrupted write, damaged upload).
- */
-async function readAviKeyframeTimes(readRange, fileSize) {
-  const head = await readRange(0, Math.min(PROBE_BYTES - 1, fileSize - 1));
-  if (!head || !isAvi(head)) {
-    return null;
-  }
-  const mainHeader = readMainHeader(head);
-  if (!mainHeader || !mainHeader.microsecondsPerFrame) {
-    return null;
-  }
-
-  const idx1 = await findIdx1(readRange, fileSize);
-  if (!idx1 || idx1.size > MAX_IDX1_BYTES) {
-    return null;
-  }
-
-  const table = await readRange(idx1.offset, Math.min(fileSize - 1, idx1.offset + idx1.size - 1));
-  if (!table || table.length < IDX1_ENTRY_BYTES) {
-    return null;
-  }
-
-  const secondsPerFrame = mainHeader.microsecondsPerFrame / 1e6;
-  const times = [];
-  let videoFrame = 0;
-  for (let at = 0; at + IDX1_ENTRY_BYTES <= table.length; at += IDX1_ENTRY_BYTES) {
-    const chunkId = table.toString("latin1", at, at + 4);
-    // Video chunks are "##db" (uncompressed) or "##dc" (compressed); audio is
-    // "##wb" and must not advance the frame counter.
-    const isVideo = chunkId.endsWith("db") || chunkId.endsWith("dc");
-    if (!isVideo) {
-      continue;
-    }
-    const flags = table.readUInt32LE(at + 4);
-    if ((flags & KEYFRAME_FLAG) !== 0) {
-      times.push(videoFrame * secondsPerFrame);
-    }
-    videoFrame += 1;
-  }
-  if (times.length === 0) {
-    return null;
-  }
-  // AVI names a keyframe by its FRAME NUMBER, and the time above is that number
-  // multiplied by the frame duration the header declares. The frames are the
-  // right ones — measured 2026-08-21 against the files themselves, 1196 index
-  // entries against 1196 real keyframes and 901 against 901, exactly — but the
-  // names are 10-44 ms away from the presentation times the demuxer computes,
-  // always under one frame. So the caller is told how far a time here may be
-  // from the instant it refers to, and can ask for a seek late enough that it
-  // still lands on the frame rather than on the one before it.
-  return { times, tolerance: secondsPerFrame };
-}

package/services/media/container/KeyframeTable.js

@@ -65,6 +65,9 @@ export class KeyframeTable {
   /** @type {boolean} */
   #answered = false;
 
+  /** @type {boolean} */
+  #copyable = true;
+
   /**
    * What copied pieces of this file have shown about the table above.
    *
@@ -141,7 +144,7 @@ export class KeyframeTable {
   }
 
   /**
-   * Whether a picture of this file can be COPIED.
+   * Whether this file has a table of keyframe times.
    *
    * A copy can only be cut where a keyframe already is, so without a table
    * there is no honest grid: declaring an even one instead is a falsehood the
@@ -155,6 +158,18 @@ export class KeyframeTable {
     return this.#times !== null;
   }
 
+  /**
+   * Whether a copy of this file's picture keeps the order its pictures are
+   * shown in. False where the container states only decoding order and the
+   * picture's codec may reorder — an AVI holding H.264 (torrent-tv/meta#151).
+   * A container that says so is never overruled by a later reading.
+   *
+   * @returns {boolean}
+   */
+  get copyable() {
+    return this.#copyable;
+  }
+
   /**
    * Take in what a reader found. Called only by `KeyframeTables`.
    *
@@ -166,12 +181,13 @@ export class KeyframeTable {
    * all 570 in 0.8 s from the index. Whichever of them answers second, the
    * fuller answer is the one that stands.
    *
-   * @param {{ times?: number[] | null, tolerance?: number, format?: string } | null} reading
+   * @param {{ times?: number[] | null, tolerance?: number, format?: string, copyable?: boolean } | null} reading
    * @returns {this}
    */
   learn(reading) {
     const wasAnswered = this.#answered;
     this.#answered = true;
+    if (reading?.copyable === false) this.#copyable = false;
     const times = Array.isArray(reading?.times) && reading.times.length > 0 ? reading.times : null;
     const format = typeof reading?.format === "string" && reading.format.length > 0 ? reading.format : "";
     const fuller = times !== null && (this.#times === null || times.length > this.#times.length);

package/services/media/container/avi-index.js

@@ -0,0 +1,297 @@
+/**
+ * @file What an AVI index states, read without reading the media it indexes.
+ *
+ * `idx1` and the OpenDML standard indexes (`ix##`, reached through each
+ * stream's `indx` super index) give, for every packet, its stream, the file
+ * position of its payload, its size and whether it is a keyframe. A packet's
+ * time follows from its place in its stream: FFmpeg's AVI demuxer advances a
+ * stream's clock by one unit per packet, or by the payload's byte count over
+ * the sample size where the stream declares one (`get_duration`, avidec.c).
+ * FFmpeg copies and decodes on exactly that clock, so these times are the
+ * times a run reading the original file will see.
+ *
+ * Nothing here reads a packet. The packet reassembly this replaces confirmed
+ * every index entry against the chunk header in `movi`, which made the
+ * keyframe table wait for nearly the whole film (torrent-tv/meta#151).
+ */
+
+import { IndexMemoryUnavailable } from "./memory-unavailable.js";
+
+const IDX1_ENTRY_BYTES = 16;
+/** Index bytes read per request; one request's worth of the proxy's input route. */
+const READ_BYTES = 1024 * 1024;
+/** Bytes held per packet: position (8), size (4), time (8), keyframe flag (1). */
+const ENTRY_BYTES = 21;
+const AVIIF_KEYFRAME = 0x10;
+
+/** One stream's packets in file order, in typed arrays. */
+class StreamPackets {
+  constructor(count) {
+    this.count = 0;
+    this.starts = new Float64Array(count);
+    this.lengths = new Uint32Array(count);
+    this.times = new Float64Array(count);
+    this.keyframes = new Uint8Array(count);
+  }
+
+  push(start, length, time, keyframe) {
+    const at = this.count++;
+    this.starts[at] = start;
+    this.lengths[at] = length;
+    this.times[at] = time;
+    this.keyframes[at] = keyframe ? 1 : 0;
+  }
+
+  /** The last packet whose time is at or before `seconds`, or 0. */
+  atOrBefore(seconds) {
+    let low = 0, high = this.count;
+    while (low < high) {
+      const middle = (low + high) >> 1;
+      if (this.times[middle] <= seconds) low = middle + 1;
+      else high = middle;
+    }
+    return Math.max(0, low - 1);
+  }
+}
+
+/**
+ * Read the index of one AVI.
+ *
+ * @param {object} params
+ * @param {(start: number, end: number) => Promise<Buffer>} params.read - Strict byte read.
+ * @param {number} params.fileSize
+ * @param {{ start: number, end: number }} params.movi - The first `movi` list (`start` at its type).
+ * @param {{ start: number, end: number } | null} params.idx1 - The `idx1` chunk's payload, if any.
+ * @param {Array<{ type: string, timeBase: number | null, sampleSize: number, startTimeSeconds: number | null,
+ *   indexChunks: Array<{ start: number, end: number }> }>} params.streams - In stream-number order.
+ * @param {{ reserve?: (bytes: number) => boolean, release?: (bytes: number) => void }} params.allocation
+ * @returns {Promise<AviIndex | null>} Null when the file states no index.
+ */
+export async function readAviIndex({ read, fileSize, movi, idx1, streams, allocation }) {
+  const useOpenDml = streams.some(stream => stream.indexChunks.length);
+  if (!useOpenDml && !idx1) return null;
+  if (streams.some(stream => ["video", "audio"].includes(stream.type) && !(stream.timeBase > 0))) {
+    throw new Error("AVI stream time base is invalid.");
+  }
+  return useOpenDml
+    ? readOpenDml({ read, fileSize, streams, allocation })
+    : readIdx1({ read, fileSize, movi, idx1, streams, allocation });
+}
+
+/** Whole entries of `unit` bytes, about one request at a time. */
+async function* blocks(read, start, end, unit) {
+  const step = Math.max(unit, Math.floor(READ_BYTES / unit) * unit);
+  for (let at = start; at < end; at += step) {
+    yield { at, bytes: await read(at, Math.min(end, at + step) - 1) };
+  }
+}
+
+function reserve(allocation, count) {
+  const bytes = count * ENTRY_BYTES;
+  if (allocation?.reserve?.(bytes) === false) throw new IndexMemoryUnavailable(bytes);
+  return bytes;
+}
+
+function durationOf(stream, length) {
+  return stream.timeBase * (stream.sampleSize > 0 ? length / stream.sampleSize : 1);
+}
+
+async function readIdx1({ read, fileSize, movi, idx1, streams, allocation }) {
+  if ((idx1.end - idx1.start) % IDX1_ENTRY_BYTES !== 0) throw new Error("AVI packet index entry is truncated.");
+  const counts = new Array(streams.length).fill(0);
+  let first = null;
+  // Entries are 16 bytes and blocks are a multiple of 16, so none straddles.
+  let anyKeyframe = false;
+  for await (const { at, bytes } of blocks(read, idx1.start, idx1.end, IDX1_ENTRY_BYTES)) {
+    for (let offset = 0; offset < bytes.length; offset += IDX1_ENTRY_BYTES) {
+      const id = streamOf(bytes.toString("ascii", offset, offset + 4), streams.length);
+      if (id === null) continue;
+      counts[id]++;
+      if (bytes.readUInt32LE(offset + 4) & AVIIF_KEYFRAME) anyKeyframe = true;
+      if (first === null && bytes.readUInt32LE(offset + 12) > 0) {
+        first = { chunkId: bytes.toString("ascii", offset, offset + 4), offset: bytes.readUInt32LE(offset + 8), length: bytes.readUInt32LE(offset + 12), at: at + offset };
+      }
+    }
+  }
+  if (first === null) return null;
+  // Offsets count from the `movi` type or from the start of the file; the one
+  // that lands on the first entry's own chunk header is the file's convention.
+  let base = null;
+  for (const candidate of [movi.start, 0, movi.start + 4]) {
+    const address = candidate + first.offset;
+    if (address < movi.start + 4 || address + 8 + first.length > movi.end) continue;
+    const head = await read(address, address + 7);
+    if (head.toString("ascii", 0, 4) === first.chunkId && head.readUInt32LE(4) === first.length) { base = candidate; break; }
+  }
+  if (base === null) throw new Error("AVI packet index has no valid offset base.");
+  const held = reserve(allocation, counts.reduce((sum, count) => sum + count, 0));
+  try {
+    const packets = counts.map(count => new StreamPackets(count));
+    const clocks = streams.map(stream => stream.startTimeSeconds ?? 0);
+    for await (const { bytes } of blocks(read, idx1.start, idx1.end, IDX1_ENTRY_BYTES)) {
+      for (let offset = 0; offset < bytes.length; offset += IDX1_ENTRY_BYTES) {
+        const chunkId = bytes.toString("ascii", offset, offset + 4);
+        const id = streamOf(chunkId, streams.length);
+        if (id === null) continue;
+        const length = bytes.readUInt32LE(offset + 12);
+        const start = base + bytes.readUInt32LE(offset + 8) + 8;
+        if (length && (start < movi.start + 12 || start + length > movi.end)) throw new Error("AVI indexed packet exceeds its media list.");
+        // FFmpeg takes the index flag alone, and every entry as a keyframe
+        // when no entry carries it (avi_read_idx1).
+        const keyframe = !anyKeyframe || !!(bytes.readUInt32LE(offset + 4) & AVIIF_KEYFRAME);
+        packets[id].push(start, length, clocks[id], keyframe);
+        clocks[id] += durationOf(streams[id], length);
+      }
+    }
+    return new AviIndex({ packets, indexRanges: [[idx1.start - 8, fileSize - 1]], held, allocation });
+  } catch (error) {
+    allocation?.release?.(held);
+    throw error;
+  }
+}
+
+async function readOpenDml({ read, fileSize, streams, allocation }) {
+  const standards = [];
+  for (const [id, stream] of streams.entries()) {
+    for (const chunk of stream.indexChunks) {
+      const header = await read(chunk.start, chunk.start + 23);
+      if (header[3] !== 0 || header.readUInt16LE(0) !== 4) {
+        throw new Error("AVI OpenDML super index structure is invalid.");
+      }
+      const count = header.readUInt32LE(4);
+      if (count > Math.floor((chunk.end - chunk.start - 24) / 16)) throw new Error("AVI OpenDML index entry count exceeds its chunk.");
+      const table = count ? await read(chunk.start + 24, chunk.start + 23 + count * 16) : Buffer.alloc(0);
+      for (let at = 0; at < count; at++) {
+        const offset = Number(table.readBigUInt64LE(at * 16)), size = table.readUInt32LE(at * 16 + 8);
+        if (!offset && !size) continue;
+        if (!Number.isSafeInteger(offset) || size < 32 || offset + size > fileSize) throw new Error("AVI OpenDML child index exceeds the file.");
+        standards.push({ id, start: offset, end: offset + size });
+      }
+    }
+  }
+  // Headers first: the entry counts decide the allocation before any table is held.
+  const parsed = [];
+  for (const standard of standards) {
+    const header = await read(standard.start, standard.start + 31);
+    if (!/^ix[0-9]{2}$/.test(header.toString("ascii", 0, 4)) || header.readUInt32LE(4) + 8 !== standard.end - standard.start) {
+      throw new Error("AVI OpenDML child index size disagrees with its header.");
+    }
+    const words = header.readUInt16LE(8), subtype = header[10], type = header[11];
+    const count = header.readUInt32LE(12), chunkId = header.toString("ascii", 16, 20);
+    if (type !== 1 || !((subtype === 0 && words === 2) || (subtype === 1 && words === 3))) throw new Error("AVI OpenDML standard index structure is invalid.");
+    if (streamOf(chunkId, streams.length) !== standard.id) throw new Error("AVI OpenDML index refers to another stream.");
+    if (count > Math.floor((standard.end - standard.start - 32) / (words * 4))) throw new Error("AVI OpenDML index entry count exceeds its chunk.");
+    const base = Number(header.readBigUInt64LE(20));
+    if (!Number.isSafeInteger(base)) throw new Error("AVI OpenDML address exceeds exact integer precision.");
+    parsed.push({ ...standard, entryBytes: words * 4, count, base });
+  }
+  const counts = new Array(streams.length).fill(0);
+  for (const standard of parsed) counts[standard.id] += standard.count;
+  const held = reserve(allocation, counts.reduce((sum, count) => sum + count, 0));
+  try {
+    const packets = counts.map(count => new StreamPackets(count));
+    const clocks = streams.map(stream => stream.startTimeSeconds ?? 0);
+    for (const standard of parsed) {
+      const stream = streams[standard.id];
+      const tableStart = standard.start + 32;
+      const tableEnd = tableStart + standard.count * standard.entryBytes;
+      for await (const { bytes } of blocks(read, tableStart, tableEnd, standard.entryBytes)) {
+        for (let offset = 0; offset + standard.entryBytes <= bytes.length; offset += standard.entryBytes) {
+          const start = standard.base + bytes.readUInt32LE(offset);
+          const encoded = bytes.readUInt32LE(offset + 4), length = encoded & 0x7fffffff;
+          if (length && (start < 8 || start + length > fileSize)) throw new Error("AVI OpenDML packet exceeds the file.");
+          packets[standard.id].push(start, length, clocks[standard.id], !(encoded & 0x80000000));
+          clocks[standard.id] += durationOf(stream, length);
+        }
+      }
+    }
+    return new AviIndex({ packets, indexRanges: parsed.map(standard => [standard.start, standard.end - 1]), held, allocation });
+  } catch (error) {
+    allocation?.release?.(held);
+    throw error;
+  }
+}
+
+/** The stream an entry belongs to; entries of no declared stream are skipped, as FFmpeg does. */
+function streamOf(chunkId, streamCount) {
+  if (!/^[0-9]{2}(db|dc|wb)$/.test(chunkId)) return null;
+  const id = Number(chunkId.slice(0, 2));
+  return id < streamCount ? id : null;
+}
+
+/** The packets an AVI index states, and the index bytes FFmpeg reads to learn them. */
+export class AviIndex {
+  #held;
+  #allocation;
+
+  constructor({ packets, indexRanges, held, allocation }) {
+    this.packets = packets;
+    this.indexRanges = indexRanges;
+    this.#held = held;
+    this.#allocation = allocation;
+  }
+
+  /** Keyframe times of a stream, ascending. */
+  keyframeTimes(stream) {
+    const packets = this.packets[stream];
+    const times = [];
+    for (let at = 0; at < packets.count; at++) if (packets.keyframes[at] && packets.lengths[at]) times.push(packets.times[at]);
+    return times;
+  }
+
+  /**
+   * The payload bytes a reader of `[from, to)` needs from each stream.
+   *
+   * The picture is taken from the keyframe two keyframes before `from` — the
+   * same margin the Matroska reading keeps in Cue points — to the keyframe that
+   * follows the one after `to`. Every other selected stream is taken over the
+   * same span of time, so an interleave that places sound ahead of or behind
+   * its picture is covered in either direction.
+   *
+   * @param {{ from: number, to: number, picture: number | null, streams: number[] }} params
+   * @returns {Array<[number, number]>}
+   */
+  mediaRanges({ from, to, picture, streams }) {
+    let first = from, last = to;
+    if (picture !== null) {
+      const video = this.packets[picture];
+      const keys = [];
+      for (let at = 0; at < video.count; at++) if (video.keyframes[at] && video.lengths[at]) keys.push(at);
+      if (!keys.length) throw new Error("AVI picture index states no keyframe.");
+      const before = keys.findLastIndex(at => video.times[at] <= from);
+      const after = keys.findIndex(at => video.times[at] >= to);
+      first = video.times[keys[Math.max(0, before - 2)]];
+      last = after < 0 || after + 1 >= keys.length ? Infinity : video.times[keys[after + 1]];
+    }
+    const ranges = [];
+    for (const stream of streams) {
+      const packets = this.packets[stream];
+      if (!packets?.count) continue;
+      const start = packets.atOrBefore(first);
+      let end = packets.count - 1;
+      if (Number.isFinite(last)) end = Math.min(end, packets.atOrBefore(last));
+      let low = Infinity, high = -1;
+      for (let at = start; at <= end; at++) {
+        if (!packets.lengths[at]) continue;
+        low = Math.min(low, packets.starts[at] - 8);
+        high = Math.max(high, packets.starts[at] + packets.lengths[at] - 1);
+      }
+      if (high >= 0) ranges.push([low, high]);
+    }
+    return ranges;
+  }
+
+  /** Where each stream's first packet begins, header included. */
+  firstPackets() {
+    return this.packets.flatMap(packets => {
+      for (let at = 0; at < packets.count; at++) if (packets.lengths[at]) return [[packets.starts[at] - 8, packets.starts[at] + 7]];
+      return [];
+    });
+  }
+
+  dispose() {
+    if (!this.#held) return;
+    this.#allocation?.release?.(this.#held);
+    this.#held = 0;
+  }
+}

package/services/media/container/avi-open-dml.js

@@ -1,47 +0,0 @@
-/** OpenDML indexes address stream payloads directly, including later RIFF AVIX forms. */
-export async function* openDmlPackets({ readRange, fileSize, indexes, streamId }) {
-  const seen = new Set();
-  for (const chunk of indexes) yield* entries(chunk, false);
-
-  async function* entries(chunk, child) {
-    if (seen.has(chunk.start)) throw new Error("AVI OpenDML repeats an index address.");
-    seen.add(chunk.start);
-    if (chunk.start < 0 || chunk.end > fileSize || chunk.end - chunk.start < 24) throw new Error("AVI OpenDML index header is truncated.");
-    const header = await readRange(chunk.start, chunk.start + 23);
-    const words = header.readUInt16LE(), subtype = header[2], type = header[3];
-    const count = header.readUInt32LE(4), chunkId = header.toString("ascii", 8, 12);
-    if (!/^[0-9]{2}(db|dc|wb)$/.test(chunkId) || Number(chunkId.slice(0, 2)) !== streamId) throw new Error("AVI OpenDML index refers to another stream.");
-    const entryBytes = words * 4;
-    if (!entryBytes || count > Math.floor((chunk.end - chunk.start - 24) / entryBytes)) throw new Error("AVI OpenDML index entry count exceeds its chunk.");
-    if (type === 0) {
-      if (child || words !== 4 || subtype !== 0) throw new Error("AVI OpenDML super index structure is invalid.");
-      for (let at = 0; at < count; at++) {
-        const entry = await readRange(chunk.start + 24 + at * 16, chunk.start + 39 + at * 16);
-        const offset = safeOffset(entry.readBigUInt64LE()), size = entry.readUInt32LE(8);
-        if (!offset && !size) continue;
-        if (size < 32 || offset + size > fileSize) throw new Error("AVI OpenDML child index exceeds the file.");
-        const prefix = await readRange(offset, offset + 7);
-        if (!/^ix[0-9]{2}$/.test(prefix.toString("ascii", 0, 4)) || prefix.readUInt32LE(4) + 8 !== size) throw new Error("AVI OpenDML child index size disagrees with its header.");
-        yield* entries({ start: offset + 8, end: offset + size }, true);
-      }
-      return;
-    }
-    if (type !== 1 || !((subtype === 0 && words === 2) || (subtype === 1 && words === 3))) throw new Error("AVI OpenDML standard index structure is invalid.");
-    const base = safeOffset(header.readBigUInt64LE(12));
-    for (let at = 0; at < count; at++) {
-      const entry = await readRange(chunk.start + 24 + at * entryBytes, chunk.start + 23 + (at + 1) * entryBytes);
-      const start = base + entry.readUInt32LE(), encodedSize = entry.readUInt32LE(4), length = encodedSize & 0x7fffffff;
-      if (!Number.isSafeInteger(start) || start < 8 || start + length > fileSize) throw new Error("AVI OpenDML packet exceeds the file.");
-      if (subtype === 1 && entry.readUInt32LE(8) >= length) throw new Error("AVI OpenDML second field exceeds its frame.");
-      if (!length) { yield { chunkId, start, length, keyframe: false }; continue; }
-      const prefix = await readRange(start - 8, start - 1);
-      if (prefix.toString("ascii", 0, 4) !== chunkId || prefix.readUInt32LE(4) !== length) throw new Error("AVI OpenDML packet disagrees with its chunk header.");
-      yield { chunkId, start, length, keyframe: !(encodedSize & 0x80000000) };
-    }
-  }
-}
-
-function safeOffset(value) {
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("AVI OpenDML address exceeds exact integer precision.");
-  return Number(value);
-}