@torrent-tv/proxy 2.91.0 → 2.92.1

package/services/media/container/CadencedPictureOrder.js

@@ -0,0 +1,45 @@
+/** A declared constant presentation cadence uses picture order as order, not time. */
+export class CadencedPictureOrder {
+  #track;
+  #index;
+  #pending = [];
+  #next;
+  #last = null;
+  #covered = 0;
+
+  constructor(track, index) {
+    this.#track = track;
+    this.#index = index;
+    this.#next = track.startTimeSeconds;
+  }
+
+  push(packet, order, reset) {
+    if (!Number.isSafeInteger(order)) throw new Error("A cadenced picture has no declared order.");
+    if (reset) { this.finish(); this.#last = null; }
+    const depth = this.#track.reorderDepth;
+    if (!Number.isSafeInteger(depth) || depth < 0 || depth > 16) throw new Error("A cadenced picture has no bounded reorder declaration.");
+    this.#pending.push({ packet, order, assigned: false });
+    if (this.#pending.filter(one => !one.assigned).length > depth + 1) this.#assign();
+  }
+
+  #assign() {
+    const one = this.#pending.filter(one => !one.assigned).reduce((first, next) => !first || next.order < first.order ? next : first, null);
+    if (!one) return;
+    if (this.#last !== null && one.order <= this.#last) throw new Error("Picture order exceeds its declared reorder bound.");
+    one.packet.pts = this.#next;
+    one.packet.duration = this.#track.presentationCadenceSeconds;
+    this.#next += one.packet.duration;
+    this.#last = one.order;
+    one.assigned = true;
+    while (this.#pending[0]?.assigned) {
+      this.#index.append(this.#track.trackNumber, this.#pending.shift().packet);
+    }
+    const through = Math.min(this.#next, ...this.#pending.filter(entry => entry.assigned).map(entry => entry.packet.pts));
+    if (through > this.#covered) {
+      this.#index.coverThrough(this.#track.trackNumber, through);
+      this.#covered = through;
+    }
+  }
+
+  finish() { while (this.#pending.length) this.#assign(); }
+}

package/services/media/container/Container.js

@@ -4,7 +4,7 @@
  * A Container knows how to read its own format's track table and index.
  * Concrete containers (MatroskaContainer, Mp4Container, AviContainer) implement
  * spec-specific parsing. All byte access goes through `readRange(start,end)` so
- * the class works over torrent piece windows.
+ * the class reads only bytes already held for the source.
  *
  * Spec refs:
  *  - Matroska RFC 9559 §5: EBML, Segment, SeekHead, Tracks, Cues, Clusters
@@ -29,7 +29,7 @@ import { strictReader } from "./unavailable.js";
 
 export class Container {
   /**
-   * One reader, the one that fetches what is missing, and one container per
+   * One strict available-byte reader and one container per
    * file — the one `ContainerOrchestrator` keeps.
    *
    * `readRange` is made strict here: it answers with every byte asked for or
@@ -53,10 +53,11 @@ export class Container {
    * @param {string} [params.label]
    * @param {number} [params.portionBytes]
    */
-  constructor({ readRange, fileSize, label = "", portionBytes } = {}) {
+  constructor({ readRange, fileSize, label = "", portionBytes, packetMemory } = {}) {
     this.fileSize = fileSize;
     this.readRange = typeof readRange === "function" ? strictReader(readRange, fileSize) : readRange;
     this.label = label;
+    this.packetMemory = packetMemory;
     this.portionBytes = Number.isFinite(portionBytes) && portionBytes > 0 ? portionBytes : Number.POSITIVE_INFINITY;
   }
 
@@ -360,6 +361,9 @@ export class Container {
     return "unknown";
   }
 
+  /** Retained binary packet storage; this excludes declarations and JS heap. */
+  packetIndexBytes() { return 0; }
+
   /** Whether `head` (first bytes) looks like this container. */
   static detect(_head) {
     return false;

package/services/media/container/ContainerFactory.js

@@ -1,15 +1,19 @@
 /**
  * @file Container factory — detects format and returns the precise Container subclass.
  *
- * Sniffs first 16 bytes (same as container-index/index.js) and instantiates
- * MatroskaContainer / Mp4Container / AviContainer. Falls back to null (unknown).
+ * Reads the first 16 bytes and selects Matroska, MP4, AVI, TS, PS or ASF.
+ * Other formats use the supplied packet probe; without a probe they return null.
  * Orchestrators depend on this, not on concrete constructors.
  */
 
 import { MatroskaContainer } from "./MatroskaContainer.js";
 import { Mp4Container } from "./Mp4Container.js";
 import { AviContainer } from "./AviContainer.js";
+import { MpegTsContainer } from "./MpegTsContainer.js";
+import { AsfContainer } from "./AsfContainer.js";
+import { MpegPsContainer } from "./MpegPsContainer.js";
 import { strictReader } from "./unavailable.js";
+import { FfprobeContainer } from "./FfprobeContainer.js";
 
 const SNIFF_BYTES = 16;
 
@@ -33,6 +37,9 @@ export class ContainerFactory {
     if (MatroskaContainer.detect(head)) return new MatroskaContainer(params);
     if (Mp4Container.detect(head)) return new Mp4Container(params);
     if (AviContainer.detect(head)) return new AviContainer(params);
-    return null;
+    if (MpegTsContainer.detect(head)) return new MpegTsContainer(params);
+    if (AsfContainer.detect(head)) return new AsfContainer(params);
+    if (MpegPsContainer.detect(head)) return new MpegPsContainer(params);
+    return typeof params.probe === "function" ? new FfprobeContainer(params) : null;
   }
 }

package/services/media/container/FfprobeContainer.js

@@ -0,0 +1,222 @@
+import { Container } from "./Container.js";
+import { PacketIndex } from "./PacketIndex.js";
+import { PacketRecords } from "./PacketRecords.js";
+import { BytesUnavailable } from "./unavailable.js";
+import { IndexMemoryUnavailable } from "./memory-unavailable.js";
+import { ffprobeExtradata } from "./ffprobe-record.js";
+import { VideoTrack } from "../tracks/VideoTrack.js";
+import { AudioTrack } from "../tracks/AudioTrack.js";
+import { SubtitleTrack } from "../tracks/SubtitleTrack.js";
+import { TextSubtitleTrack } from "../tracks/TextSubtitleTrack.js";
+import { MatroskaContainer } from "./MatroskaContainer.js";
+import { Mp4Container } from "./Mp4Container.js";
+import { flvPacketRanges } from "./flv-packet-ranges.js";
+
+const TEXT_CODECS = new Map([
+  ["subrip", "S_TEXT/UTF8"], ["srt", "S_TEXT/UTF8"],
+  ["ass", "S_TEXT/ASS"], ["ssa", "S_TEXT/SSA"],
+  ["webvtt", "S_TEXT/WEBVTT"], ["vtt", "S_TEXT/WEBVTT"],
+  ["mov_text", "tx3g"], ["text", "S_TEXT/UTF8"]
+]);
+
+const indexed = track => track.type === "video" || track.type === "audio" ||
+  (track.type === "subtitle" && track.isTextBased());
+
+/** Additional formats use the same strict byte reader through an injected demuxer. */
+export class FfprobeContainer extends Container {
+  #probe;
+  #tracks;
+  #info;
+  #index;
+  #records;
+  #complete = false;
+  #packetScanComplete = false;
+  #indexedRecords = 0;
+  #timings = new Map();
+
+  constructor(params) {
+    super(params);
+    this.#probe = params.probe;
+    this.#records = new PacketRecords(this.packetMemory);
+  }
+  get formatName() { return "ffprobe"; }
+  packetIndexBytes() { return this.#index?.allocatedBytes() ?? 0; }
+
+  async #read(statement, onRecord) {
+    const result = await this.#probe(statement, onRecord);
+    if (result.kind === "needs-memory") throw new IndexMemoryUnavailable(result.bytes);
+    if (result.kind === "needs-ranges") {
+      const [start, end] = result.ranges[0];
+      throw new BytesUnavailable(start, end, 0);
+    }
+    if (result.kind !== "result") throw new Error(result.message ?? result.reason ?? "Packet probe was cancelled.");
+    return result.value;
+  }
+
+  async readTracks() {
+    if (this.#tracks) return this.#tracks;
+    const records = await this.#read("streams");
+    const counts = { video: 0, audio: 0, subtitle: 0 };
+    const tracks = [];
+    for (const record of records) {
+      if (record.kind !== "stream" || !Object.hasOwn(counts, record.codec_type)) continue;
+      const stream = integer(record.index, "stream index");
+      if (tracks.some(track => track.trackNumber === stream + 1)) throw new Error("Duplicate ffprobe stream.");
+      const privateSize = record.extradata_size === undefined ? 0 : integer(record.extradata_size, "extradata size");
+      const base = { trackNumber: stream + 1, declaredIndex: counts[record.codec_type]++, codecId: record.codec_name,
+        language: record["tag:language"] ?? "", declaresLanguage: Object.hasOwn(record, "tag:language"),
+        name: record["tag:title"] ?? "", isEnabled: true, isDefault: record["disposition:default"] === "1",
+        declaresDefault: Object.hasOwn(record, "disposition:default"),
+        codecPrivateB64: privateSize ? ffprobeExtradata(record.extradata, privateSize).toString("base64") : "" };
+      if (base.codecId === "alac" && privateSize) {
+        const atom = Buffer.from(base.codecPrivateB64, "base64");
+        if (atom.length < 36 || atom.readUInt32BE() !== atom.length || atom.toString("ascii", 4, 8) !== "alac") {
+          throw new Error("The ALAC probe did not supply a complete decoder atom.");
+        }
+        base.codecPrivateB64 = atom.subarray(12).toString("base64");
+      }
+      let track;
+      if (record.codec_type === "video") {
+        track = new VideoTrack({ ...base, width: number(record.width), height: number(record.height), fps: ratio(record.r_frame_rate) });
+        track.reorderDepth = record.has_b_frames === undefined ? 0 : integer(record.has_b_frames, "reorder depth");
+      } else if (record.codec_type === "audio") {
+        track = new AudioTrack({ ...base, channels: number(record.channels), samplingFrequency: number(record.sample_rate),
+          bitDepth: Number(/^pcm_[suf](\d+)/.exec(record.codec_name)?.[1]) ||
+            number(record.bits_per_raw_sample) || number(record.bits_per_sample) || null });
+        track.prerollSeconds = track.codecId === "opus" ? 0.08 : 0;
+        if (track.codecId === "opus") {
+          const head = Buffer.from(track.codecPrivateB64, "base64");
+          if (head.length < 19 || head.toString("ascii", 0, 8) !== "OpusHead") throw new Error("Opus decoder configuration is absent.");
+          track.codecDelaySeconds = head.readUInt16LE(10) / 48000;
+          track.seekPrerollSeconds = 0.08;
+        }
+      } else {
+        const codecId = TEXT_CODECS.get(record.codec_name);
+        const Type = codecId ? TextSubtitleTrack : SubtitleTrack;
+        track = new Type({ ...base, ...(codecId ? { codecId } : {}), isForced: record["disposition:forced"] === "1" });
+      }
+      tracks.push(track);
+    }
+    if (!tracks.length) throw new Error("The packet probe found no declared media streams.");
+    const format = records.find(record => record.kind === "format");
+    this.#info = { format: format?.format_name ?? "unknown", durationSeconds: number(format?.duration), startTimeSeconds: number(format?.start_time) };
+    this.#tracks = tracks;
+    return tracks;
+  }
+
+  async readMediaInfo() { await this.readTracks(); return this.#info; }
+
+  async readPacketIndex(interval) {
+    const tracks = await this.readTracks();
+    if (this.#complete) return this.#index;
+    let position = 0;
+    let missing;
+    try { if (!this.#packetScanComplete) await this.#read("packets", record => {
+      if (record.kind === "scan-start") { position = 0; return; }
+      if (record.kind === "scan-end") {
+        if (position !== this.#records.length) throw new Error("Packet scan ended before its retained index.");
+        this.#packetScanComplete = true;
+        return;
+      }
+      if (record.kind !== "packet") return;
+      const streamId = integer(record.stream_index, "packet stream") + 1;
+      const track = tracks.find(track => track.trackNumber === streamId);
+      if (!track || !indexed(track)) return;
+      const start = integer(record.pos, "packet address"), size = integer(record.size, "packet size");
+      if (!size || !Number.isSafeInteger(start + size) || start + size > this.fileSize) throw new Error("Packet bytes are outside the source file.");
+      const pts = number(record.pts_time), duration = number(record.duration_time);
+      const dts = number(record.dts_time) ?? (track.type === "subtitle" ? pts : null);
+      if (pts === null || dts === null || duration === null || duration < 0 ||
+          (duration === 0 && track.type !== "subtitle")) throw new Error("The demuxer cannot state complete packet timing.");
+      const expectedHash = /^SHA256:([a-fA-F0-9]{64})$/.exec(record.data_hash ?? "")?.[1]?.toLowerCase();
+      if (!expectedHash) throw new Error("The demuxer cannot verify packet byte addresses.");
+      const packet = { pts, dts, duration, keyframe: record.flags?.includes("K") === true,
+        ranges: [[start, start + size - 1]], expectedHash, streamId };
+      const previous = this.#records.at(position++);
+      if (previous) {
+        if (previous.pts !== pts || previous.dts !== dts || previous.duration !== duration ||
+            previous.keyframe !== packet.keyframe || previous.streamId !== streamId || previous.expectedHash !== expectedHash ||
+            previous.ranges[0][0] !== start || previous.ranges[0][1] !== start + size - 1) {
+          throw new Error("Repeated packet scan changed a previously indexed packet.");
+        }
+      } else this.#records.push(packet);
+    }); } catch (error) {
+      if (!(error instanceof BytesUnavailable)) throw error;
+      missing = error;
+    }
+    if (!missing && !this.#packetScanComplete) throw new Error("Packet scan did not report its completion.");
+    const index = this.#index ?? new PacketIndex({ packetMemory: this.packetMemory });
+    const timings = this.#timings;
+    if (!this.#index) {
+    for (const track of tracks) {
+      if (!indexed(track)) continue;
+      index.declareTrack(track.trackNumber, { type: track.type, codecId: track.codecId, reorderDepth: track.reorderDepth ?? 0, prerollSeconds: track.prerollSeconds ?? 0 });
+    }
+    this.#index = index;
+    }
+    while (this.#indexedRecords < this.#records.length) {
+      const record = this.#records.at(this.#indexedRecords);
+      const id = record.streamId;
+      const track = tracks.find(track => track.trackNumber === id);
+      const start = record.ranges[0][0], size = record.ranges[0][1] - start + 1;
+      const { pts, dts, duration } = record;
+      const ranges = this.#info.format.split(",").includes("flv")
+        ? await flvPacketRanges({ readRange: this.readRange, fileSize: this.fileSize, position: start, size, track, pts, dts })
+        : [[start, start + size - 1]];
+      index.append(id, { pts, dts, duration, keyframe: record.keyframe,
+        ranges, expectedHash: record.expectedHash });
+      const timing = timings.get(id) ?? { count: 0, tail: [] };
+      timing.count++;
+      timing.tail.push({ pts, duration });
+      const keep = track.type === "video" ? track.reorderDepth + 1 : 1;
+      if (timing.tail.length > keep) timing.tail.shift();
+      timings.set(id, timing);
+      this.#indexedRecords++;
+    }
+    for (const track of tracks) {
+      if (!indexed(track)) continue;
+      if (!missing) index.complete(track.trackNumber);
+      else {
+        const timing = timings.get(track.trackNumber) ?? { count: 0, tail: [] };
+        const tail = timing.tail;
+        if (tail.length && (track.type !== "video" || timing.count > track.reorderDepth)) {
+          const through = track.type === "video" ? Math.min(...tail.map(packet => packet.pts)) : tail[0].pts + tail[0].duration;
+          index.coverThrough(track.trackNumber, Math.max(0, through));
+        }
+      }
+    }
+    if (missing) {
+      if (!interval || tracks.filter(track => indexed(track) &&
+        (!interval.trackIds || interval.trackIds.includes(track.trackNumber))).some(track =>
+        index.inputFor({ trackId: track.trackNumber, from: interval.from, to: interval.to }).kind !== "result")) throw missing;
+      return index;
+    }
+    this.#index = index;
+    this.#complete = true;
+    this.#records.dispose();
+    return index;
+  }
+
+  async parseKeyframeIndex() {
+    const tracks = await this.readTracks();
+    const video = tracks.find(track => track.type === "video");
+    if (!video) return null;
+    return { times: (await this.readPacketIndex()).keyframesOf(video.trackNumber), tolerance: 0 };
+  }
+
+  static cueTextOf(payload, codecId) {
+    if (codecId === "tx3g") return Mp4Container.cueTextOf(payload, codecId);
+    return MatroskaContainer.cueTextOf(payload, codecId);
+  }
+}
+
+function number(value) { return value !== undefined && value !== "N/A" && Number.isFinite(Number(value)) ? Number(value) : null; }
+function integer(value, field) {
+  const result = number(value);
+  if (!Number.isSafeInteger(result) || result < 0) throw new Error(`The demuxer cannot state ${field}.`);
+  return result;
+}
+function ratio(value) {
+  const [numerator, denominator] = String(value ?? "").split("/").map(Number);
+  return numerator > 0 && denominator > 0 ? numerator / denominator : null;
+}

package/services/media/container/MatroskaContainer.js

@@ -34,16 +34,17 @@
 
 import { Container } from "./Container.js";
 import { VideoTrack } from "../tracks/VideoTrack.js";
+import { h264Configuration } from "./h264-configuration.js";
+import { hevcConfiguration } from "./hevc-configuration.js";
 import { AudioTrack } from "../tracks/AudioTrack.js";
 import { TextSubtitleTrack, TEXT_CODECS_MATROSKA } from "../tracks/TextSubtitleTrack.js";
 import { ImageSubtitleTrack } from "../tracks/ImageSubtitleTrack.js";
 import { ContainerTrack } from "../tracks/ContainerTrack.js";
-import { iterateElements, readFloat, readUint, readVint } from "./ebml-reader.js";
-import { ElementReader, sizeIsUnknown } from "./ebml-stream.js";
+import { iterateElements, readFloat, readUint } from "./ebml-reader.js";
+import { ElementReader } from "./ebml-stream.js";
 import { firstFrameOffset, readBlockHeader, walkHeldClusters } from "./matroska-clusters.js";
-
-/** Enough to hold the EBML header and the Segment's own header. */
-const HEAD_BYTES = 64 * 1024;
+import { readMatroskaPackets } from "./matroska-packets.js";
+import { RetainedReads } from "./RetainedReads.js";
 
 const ID_EBML = 0x1a45dfa3;
 const ID_SEGMENT = 0x18538067;
@@ -91,6 +92,7 @@ const ID_DISPLAY_WIDTH = 0x54b0;
 const ID_DISPLAY_HEIGHT = 0x54ba;
 const ID_SAMPLING_FREQUENCY = 0xb5;
 const ID_CHANNELS = 0x9f;
+const ID_AUDIO_BIT_DEPTH = 0x6264;
 
 /** RFC 9559 §5.1.2.1: nanoseconds per tick when Info omits TimestampScale. */
 const DEFAULT_TIMESTAMP_SCALE = 1_000_000;
@@ -127,13 +129,15 @@ function readString(buf, el) {
 
 export class MatroskaContainer extends Container {
   /** @type {Buffer | null} */
-  #head = null;
+  #declarations = null;
 
   /** @type {SegmentLayout | null} */
   #layout = null;
 
   /** @type {Array<import("../tracks/ContainerTrack.js").ContainerTrack> | null} */
   #tracks = null;
+  #packets = null;
+  #packetState = {};
 
   /**
    * The Cues reading: undefined until read, null when the file has none.
@@ -145,6 +149,11 @@ export class MatroskaContainer extends Container {
     return "matroska";
   }
 
+  packetIndexBytes() {
+    return (this.#packets?.allocatedBytes() ?? 0) +
+      [...(this.#packetState.packets?.values() ?? [])].reduce((sum, records) => sum + records.allocatedBytes, 0);
+  }
+
   static detect(head) {
     return isMatroska(head);
   }
@@ -218,14 +227,6 @@ export class MatroskaContainer extends Container {
     });
   }
 
-  /** @returns {Promise<Buffer>} */
-  async #headBytes() {
-    if (this.#head === null) {
-      this.#head = await this.readRange(0, Math.min(HEAD_BYTES, this.fileSize) - 1);
-    }
-    return this.#head;
-  }
-
   /**
    * Where the Segment's top-level elements are.
    *
@@ -242,18 +243,22 @@ export class MatroskaContainer extends Container {
     if (this.#layout !== null) {
       return this.#layout;
     }
-    const head = await this.#headBytes();
-    if (!isMatroska(head)) {
-      return null;
+    const reader = new ElementReader({ read: this.readRange, fileSize: this.fileSize, portionBytes: this.portionBytes });
+    let segment = null;
+    for (let at = 0; at < this.fileSize;) {
+      const header = await reader.header(at, this.fileSize);
+      if (!header || (at === 0 && header.id !== ID_EBML)) return null;
+      if (header.end !== null && header.end > this.fileSize) throw new Error("Matroska top-level element exceeds the file.");
+      if (header.id === ID_SEGMENT) { segment = header; break; }
+      if (header.end === null || header.end <= at) throw new Error("Matroska top-level element has no bounded next position.");
+      at = header.end;
     }
-    const segment = segmentHeaderIn(head);
     if (!segment) {
       return null;
     }
     const segmentDataOffset = segment.dataOffset;
     const segmentEnd = segment.size === null ? this.fileSize : Math.min(this.fileSize, segmentDataOffset + segment.size);
 
-    const reader = new ElementReader({ read: this.readRange, fileSize: this.fileSize, portionBytes: this.portionBytes });
     /** @type {Map<number, number>} */
     const found = new Map();
     /** @type {Map<number, number>} */
@@ -367,6 +372,7 @@ export class MatroskaContainer extends Container {
    * @returns {Promise<import("../tracks/index.js").ContainerTrack[]>}
    */
   async readTracks() {
+    this.#declarations ??= new RetainedReads(this.packetMemory);
     if (this.#tracks !== null) {
       return this.#tracks;
     }
@@ -392,7 +398,8 @@ export class MatroskaContainer extends Container {
         break;
       }
       if (entry.id === ID_TRACK_ENTRY) {
-        const data = await within.data(entry);
+        const data = entry.size === 0 ? Buffer.alloc(0) : entry.size > this.portionBytes ? null
+          : await this.#declarations.read(entry.dataOffset, entry.end - 1, () => within.data(entry));
         // An entry larger than one portion is refused rather than assembled.
         // Its type cannot be known without its data, so it is kept as a track
         // of no kind — which makes the count of its kind short by one, and
@@ -401,6 +408,20 @@ export class MatroskaContainer extends Container {
         const fields = data ? parseTrackEntry(data) : { refused: true, trackNumber: null };
         const track = trackFrom(fields, counters);
         if (track) {
+          if (["V_MPEG4/ISO/AVC", "V_MPEGH/ISO/HEVC"].includes(track.codecId) && track.codecPrivateB64) {
+            const configuration = (track.codecId === "V_MPEG4/ISO/AVC" ? h264Configuration : hevcConfiguration)(Buffer.from(track.codecPrivateB64, "base64"));
+            track.codecConfiguration = configuration;
+            track.reorderDepth = configuration.reorderDepth;
+            track.width = configuration.width;
+            track.height = configuration.height;
+            track.bitDepth = configuration.bitDepth;
+            track.fps = configuration.fps ?? track.fps;
+          }
+          track.defaultDurationSeconds = fields.defaultDurationSeconds || track.defaultDurationSeconds || 0;
+          track.seekPrerollSeconds = Math.max(fields.seekPrerollSeconds ?? 0, track.seekPrerollSeconds ?? 0);
+          track.codecDelaySeconds = fields.codecDelaySeconds ?? 0;
+          track.timestampScale = fields.timestampScale ?? 1;
+          track.codecRanges = [[entry.dataOffset, entry.end - 1]];
           result.push(track);
         }
       }
@@ -410,6 +431,22 @@ export class MatroskaContainer extends Container {
     return result;
   }
 
+  async readPacketIndex(interval) {
+    if (this.#packets) return this.#packets;
+    const layout = await this.#segmentLayout();
+    if (!layout) throw new Error("Matroska Segment is absent.");
+    const tracks = await this.readTracks();
+    const info = await this.readMediaInfo();
+    const index = await readMatroskaPackets({ readRange: this.readRange,
+      fileSize: this.fileSize, portionBytes: this.portionBytes, layout, tracks,
+      durationSeconds: info.durationSeconds, interval, state: this.#packetState, packetMemory: this.packetMemory });
+    if (index.isComplete()) {
+      this.#packets = index;
+      this.#packetState = {};
+    }
+    return index;
+  }
+
   /**
    * The Cues table, read once, every CuePoint with every track it names.
    *
@@ -600,7 +637,13 @@ export class MatroskaContainer extends Container {
    */
   static cueTextOf(payload, codecId) {
     const text = Buffer.isBuffer(payload) ? payload.toString("utf8") : String(payload ?? "");
-    if (codecId !== "S_TEXT/ASS" && codecId !== "S_TEXT/SSA") {
+    if (String(codecId).startsWith("D_WEBVTT/")) {
+      // WebM blocks prefix the cue with its identifier and settings lines.
+      const first = text.indexOf("\n"), second = text.indexOf("\n", first + 1);
+      if (first < 0 || second < 0) throw new Error("WebM subtitle cue prefixes are truncated.");
+      return text.slice(second + 1);
+    }
+    if (!["S_TEXT/ASS", "S_TEXT/SSA", "S_ASS", "S_SSA"].includes(codecId)) {
       return text;
     }
     const fields = text.split(",");
@@ -658,30 +701,6 @@ function isMatroska(head) {
   return head.length >= 4 && head.readUInt32BE(0) === ID_EBML;
 }
 
-/**
- * The Segment element's header, from the top-level elements of the head.
- *
- * @param {Buffer} head
- * @returns {{ dataOffset: number, size: number | null } | null} `size` is null
- *   for an unknown-sized Segment (RFC 8794 §6.2), which runs to the file's end.
- */
-function segmentHeaderIn(head) {
-  let offset = 0;
-  while (offset < head.length) {
-    const id = readVint(head, offset, true);
-    const size = id && readVint(head, offset + id.length, false);
-    if (!id || !size) {
-      return null;
-    }
-    const dataOffset = offset + id.length + size.length;
-    if (id.value === ID_SEGMENT) {
-      return { dataOffset, size: sizeIsUnknown(size) ? null : size.value };
-    }
-    offset = dataOffset + size.value;
-  }
-  return null;
-}
-
 /**
  * The SeekHead's entries, id to position relative to the Segment's data.
  *
@@ -818,6 +837,10 @@ function parseTrackEntry(data) {
   };
   for (const f of iterateElements(data)) {
     switch (f.id) {
+      case 0x23e383: fields.defaultDurationSeconds = readUint(data, f.dataOffset, f.size) / 1e9; break;
+      case 0x56bb: fields.seekPrerollSeconds = readUint(data, f.dataOffset, f.size) / 1e9; break;
+      case 0x56aa: fields.codecDelaySeconds = readUint(data, f.dataOffset, f.size) / 1e9; break;
+      case 0x23314f: fields.timestampScale = readFloat(data, f.dataOffset, f.size); break;
       case ID_TRACK_NUMBER: fields.trackNumber = readUint(data, f.dataOffset, f.size); break;
       case ID_TRACK_TYPE: fields.type = readUint(data, f.dataOffset, f.size); break;
       case ID_CODEC_ID: fields.codecId = readString(data, f); break;
@@ -853,6 +876,8 @@ function parseTrackEntry(data) {
             fields.samplingFreq = af.size === 8 ? data.readDoubleBE(af.dataOffset) : readFloat(data, af.dataOffset, af.size);
           } else if (af.id === ID_CHANNELS) {
             fields.channels = readUint(data, af.dataOffset, af.size);
+          } else if (af.id === ID_AUDIO_BIT_DEPTH) {
+            fields.bitDepth = readUint(data, af.dataOffset, af.size);
           }
         }
         break;
@@ -916,7 +941,8 @@ function trackFrom(fields, counters) {
       isCommentary: fields.isCommentary,
       isVisualImpaired: fields.isVisual,
       channels: fields.channels,
-      samplingFrequency: fields.samplingFreq
+      samplingFrequency: fields.samplingFreq,
+      bitDepth: fields.bitDepth
     });
   }
   if (fields.type === TRACK_TYPE_SUBTITLE) {