@torrent-tv/proxy 2.88.3 → 2.88.5

package/services/encode/quality/link-budget.js

@@ -10,18 +10,19 @@
  * picture's own stream, or as a separate one — so both are added before the
  * link is asked. And each part says how much its figure can be trusted:
  *
- * 1. `known` — a bound the encoder is held to: a re-encode's `maxrate`, or the
- *    constant rate a re-encoded soundtrack is produced at;
- * 2. `estimated` — a figure the FILE states: a copied picture's average rate,
- *    a copied soundtrack's stated rate. An average is not a bound, so a load
- *    built on it is admitted only by estimate and is never confirmed;
+ * 1. `known` — a bound the stream is held to: a re-encode's `maxrate`, or the
+ *    most a copied soundtrack's codec allows it to carry;
+ * 2. `estimated` — an average: a copied picture's or soundtrack's rate as the
+ *    FILE states it, or the target a re-encoded soundtrack is asked for. An
+ *    average is not a bound, so a load built on it is admitted only by
+ *    estimate and is never confirmed;
  * 3. `unknown` — no figure at all: a hardware encoder given no limit, a copied
  *    soundtrack whose rate nothing states.
  *
  * A load is as trustworthy as its least trustworthy part.
  */
 
-import { maxrateKbpsFor, nominalKbpsFor } from "../args.js";
+import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor, nominalKbpsFor } from "../args.js";
 
 /**
  * How much of a measured link may be spent on the stream.
@@ -142,23 +143,93 @@ export function videoLoadOfLimit(nominalKbps) {
 }
 
 /**
- * The soundtrack part of a load: the track THIS viewer chose.
+ * The soundtrack part of a load: the track THIS viewer receives, in the mode
+ * it is actually produced in.
  *
- * @param {{ transcode: boolean, bitrateKbps: number | null } | null} track -
- *   Null when the viewer receives no sound from this output or beside it.
- * @param {number} transcodeKbps - What a re-encoded track is produced at.
+ * Copied, the track weighs what its codec allows it to — the bound its
+ * configuration is held to, `known` — and where no such bound is confirmed, the
+ * average the file states for it, `estimated`. Re-encoded, it weighs the rate
+ * the encoder is asked for, and that is `estimated` too: ffmpeg's AAC encoder
+ * treats `-b:a` as a target its rate control drifts towards, not a limit
+ * (`libavcodec/aacenc.c`, 8.1.2), and the 6144-bit frame limit it does hold
+ * cannot be turned into a rate without the output's sampling frequency, which
+ * the command does not fix. `research/soundtrack-rate-bound-2026-10-01.md`.
+ *
+ * @param {import("../../media/audio-inventory.js").AudioInventoryEntry | null | undefined} entry -
+ *   The inventory entry of the track; null when nothing describes it.
+ * @param {boolean | null} transcode - How it reaches the viewer; null when the
+ *   viewer receives no sound from this output or beside it.
  * @returns {LoadPart | null}
  */
-export function audioLoadOf(track, transcodeKbps) {
-  if (!track) {
+export function soundtrackLoadOf(entry, transcode) {
+  if (transcode === null || transcode === undefined) {
     return null;
   }
-  if (track.transcode === true) {
-    return part(transcodeKbps / 1000, PEAK_CLASS.KNOWN);
+  if (transcode === true) {
+    return part(AUDIO_TRANSCODE_KBPS / 1000, PEAK_CLASS.ESTIMATED);
+  }
+  const peakKbps = Number(entry?.peakKbps);
+  if (Number.isFinite(peakKbps) && peakKbps > 0) {
+    return part(peakKbps / 1000, PEAK_CLASS.KNOWN);
+  }
+  return part((Number(entry?.bitrateKbps) || 0) / 1000, PEAK_CLASS.ESTIMATED);
+}
+
+/**
+ * Whether a copied track has a figure for the link to be asked about: a
+ * confirmed bound, or a rate the file states.
+ *
+ * @param {import("../../media/audio-inventory.js").AudioInventoryEntry | null | undefined} entry
+ * @returns {boolean}
+ */
+export function soundtrackHasFigure(entry) {
+  const peakKbps = Number(entry?.peakKbps);
+  const bitrateKbps = Number(entry?.bitrateKbps);
+  return (Number.isFinite(peakKbps) && peakKbps > 0) || (Number.isFinite(bitrateKbps) && bitrateKbps > 0);
+}
+
+/**
+ * How a soundtrack is produced for a viewer, decided once, when they choose it.
+ *
+ * 1. the browser plays the track as it is and the track has a figure — copied;
+ * 2. the browser cannot play it, or it has no figure at all — re-encoded to AAC,
+ *    where re-encoding is allowed. Without a figure the link cannot be asked
+ *    whether a copy fits it, and the re-encode is the soundtrack that does have
+ *    one;
+ * 3. re-encoding not allowed: a track the browser plays is copied, figure or
+ *    not, and the link's own answer about it stands; a track it cannot play
+ *    cannot be served at all.
+ *
+ * @param {object} params
+ * @param {import("../../media/audio-inventory.js").AudioInventoryEntry | null | undefined} params.entry
+ * @param {boolean} params.browserPlays - Whether the viewer's browser can play
+ *   this track's codec as it stands.
+ * @param {boolean} params.transcodeAllowed
+ * @returns {{ transcode: boolean | null, cause: string }} `transcode: null`
+ *   when the track cannot be served. `cause` is one of {@link SOUNDTRACK_MODE_CAUSE}.
+ */
+export function chooseSoundtrackMode({ entry, browserPlays, transcodeAllowed }) {
+  const hasFigure = soundtrackHasFigure(entry);
+  if (browserPlays && hasFigure) {
+    return { transcode: false, cause: SOUNDTRACK_MODE_CAUSE.COPY };
+  }
+  if (transcodeAllowed) {
+    return { transcode: true, cause: browserPlays ? SOUNDTRACK_MODE_CAUSE.NO_FIGURE : SOUNDTRACK_MODE_CAUSE.UNPLAYABLE };
   }
-  return part((Number(track.bitrateKbps) || 0) / 1000, PEAK_CLASS.ESTIMATED);
+  return browserPlays
+    ? { transcode: false, cause: SOUNDTRACK_MODE_CAUSE.COPY_WITHOUT_FIGURE }
+    : { transcode: null, cause: SOUNDTRACK_MODE_CAUSE.CANNOT_SERVE };
 }
 
+/** Why a soundtrack is produced the way {@link chooseSoundtrackMode} decided. */
+export const SOUNDTRACK_MODE_CAUSE = Object.freeze({
+  COPY: "copied: the browser plays it and its rate is stated",
+  NO_FIGURE: "re-encoded: nothing states how much a copy of it would carry",
+  UNPLAYABLE: "re-encoded: the browser cannot play it as it is",
+  COPY_WITHOUT_FIGURE: "copied without a stated rate: re-encoding is not allowed here",
+  CANNOT_SERVE: "the browser cannot play it and re-encoding is not allowed here"
+});
+
 /**
  * The whole load: the parts added, and the class of the least trustworthy.
  *
@@ -216,6 +287,30 @@ export function linkCouldCarry(linkMbps, load) {
     : answer(LINK_VERDICT.ESTIMATED_TO_FIT, true, false);
 }
 
+/**
+ * Why a link refused a load, in words naming what was missing or too much.
+ *
+ * `no safe bound` names every part that has no figure — the picture, the
+ * soundtrack or both — because that, and not the link, is what the refusal is
+ * about. Any other refusal is about the size of the load and is described by
+ * the caller, who knows which outputs were weighed.
+ *
+ * @param {{ verdict: string, load: Load }} answer
+ * @param {string} otherwise - The words for a load that is too large.
+ * @returns {string}
+ */
+export function linkRefusalReason(answer, otherwise) {
+  if (answer?.verdict !== LINK_VERDICT.NO_SAFE_BOUND) {
+    return otherwise;
+  }
+  const missing = [
+    answer.load?.video?.peakClass === PEAK_CLASS.UNKNOWN ? "the picture" : "",
+    answer.load?.audio?.peakClass === PEAK_CLASS.UNKNOWN ? "the soundtrack" : ""
+  ].filter(Boolean);
+  return `nothing states how much ${missing.length > 0 ? missing.join(" or ") : "this output"} would send, ` +
+    "so this viewer's link cannot be asked whether it fits";
+}
+
 /**
  * How strongly an answer is admitted, for ordering: a load whose figure is a
  * bound before one whose figure is an average, and both before one with no

package/services/encode/quality/output-format.js

@@ -38,7 +38,7 @@ import { computeOutputDimensions, nominalKbpsFor, softwareRateControlFor } from
 import { buildResolutionLadder, canSustainOutput, pickSoftwarePreset } from "../hwaccel.js";
 import { OutputSpec } from "../output/OutputSpec.js";
 import { chooseServingOutput, nextRungAreaBelow, servingCandidates } from "./serving-output.js";
-import { linkAnswerFigures, linkCouldCarry, loadOf, videoLoadOfSpec } from "./link-budget.js";
+import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoadOfSpec } from "./link-budget.js";
 
 /**
  * @param {object} params
@@ -124,7 +124,7 @@ export function decideOutputFormat({
     const answer = judge(spec);
     return answer.admitted
       ? given(spec, answer)
-      : refused(spec, answer, "the source's own picture is more than this viewer's link carries");
+      : refused(spec, answer, linkRefusalReason(answer, "the source's own picture is more than this viewer's link carries"));
   }
 
   const ceiling = computeOutputDimensions(target.width, target.height, source.width, source.height);
@@ -304,12 +304,16 @@ export function decideOutputFormat({
       }
     };
   }
+  const wantedAnswer = judge(wantedSpec);
   return refused(
     wantedSpec,
-    judge(wantedSpec),
-    serving.mode === "manual"
-      ? "no limit of the size picked is admitted by this viewer's link"
-      : "no size and limit this viewer's ladder offers is admitted by their link",
+    wantedAnswer,
+    linkRefusalReason(
+      wantedAnswer,
+      serving.mode === "manual"
+        ? "no limit of the size picked is admitted by this viewer's link"
+        : "no size and limit this viewer's ladder offers is admitted by their link"
+    ),
     { budget, wantedKey }
   );
 }

package/services/encode/segment-formats/fmp4.js

@@ -14,6 +14,7 @@ import {
   continuePresentationRanges,
   rebaseSegmentDecodeTimes,
   neutralizeEmptyEdits,
+  presentationCoverageEnd,
   readPresentationRanges,
   readSelfContainedStartSeconds,
   readTrackTimescales,
@@ -281,6 +282,7 @@ export const fmp4Format = {
    * transcode itself; the box walk never descends into `mdat`.
    */
   needsSegmentRewrite: true,
+  mediaCoverageEnd: presentationCoverageEnd,
   readMediaRanges(raw, { initBytes = null, startSeconds = 0 } = {}) {
     if (this.extractInit(raw)) return readPresentationRanges(raw);
     if (!initBytes?.length) return undefined;

package/services/encode/segment-formats/mp4-boxes.js

@@ -267,6 +267,14 @@ export function readPresentationRanges(raw) {
   return result;
 }
 
+/** Last continuous coded-frame boundary on every track in a closed piece. */
+export function presentationCoverageEnd(ranges) {
+  const tracks = presentationTracks.get(ranges);
+  if (!tracks?.length) return null;
+  return Math.min(...tracks.map(({ frameRanges, precision }) => Math.max(...frameRanges.map((range) =>
+    range.lastFrameStart + 2 * range.maxFrameDuration + precision))));
+}
+
 /** A video frame can cross a file boundary when decoding remains continuous. */
 export function continuePresentationRanges(ranges, nextRanges) {
   const tracks = presentationTracks.get(ranges);
@@ -306,7 +314,10 @@ export function translatePresentationRanges(ranges, initBytes, timestampOffsetSe
     ranges: held.map(({ start, end }, index) => ({
       start: Math.max(0, start + timestampOffsetSeconds - (edits.get(id) ?? 0)),
       end: end + timestampOffsetSeconds - (edits.get(id) ?? 0),
-      ...(kind === "soun" ? {
+      // Chromium joins continuous audio and video within twice the measured
+      // frame distance. This is a coded-frame rule, not an ETA tolerance.
+      // https://chromium.googlesource.com/chromium/src/+/refs/heads/main/media/filters/source_buffer_stream.cc
+      ...(["soun", "vide"].includes(kind) ? {
         joinEnd: frameRanges[index].lastFrameStart + 2 * frameRanges[index].maxFrameDuration +
           timestampOffsetSeconds - (edits.get(id) ?? 0)
       } : {})

package/services/media/audio-inventory.js

@@ -30,6 +30,7 @@
 
 
 import { AudioTrack } from "./tracks/AudioTrack.js";
+import { codecParametersComplete, codecParametersConflict, peakKbpsOf } from "./tracks/audio-bound.js";
 
 
 
@@ -57,6 +58,12 @@ import { AudioTrack } from "./tracks/AudioTrack.js";
  * @property {boolean} isEnabled
  * @property {number | null} channels
  * @property {number | null} bitrateKbps - The rate the file states for this track; an average, not a bound.
+ * @property {import("./tracks/audio-bound.js").CodecParameters | null} codecParameters -
+ *   The codec's configuration as the container states it, or null where no
+ *   track table was read.
+ * @property {number | null} peakKbps - The most the codec, so configured, allows
+ *   this track to carry — a bound, not an average — or null where no confirmed
+ *   bound exists for that configuration (`tracks/audio-bound.js`).
  * @property {string} fileName - For a sidecar: its own file name. "" otherwise.
  * @property {string[]} folders - For a sidecar: the folders above it, relative
  *   to the torrent root. What the browser reads a language and a releaser from.
@@ -106,11 +113,14 @@ export function buildAudioInventory({ embedded, videoFileIndex, sidecars }) {
       isVisualImpaired: track?.isVisualImpaired === true,
       isEnabled: track?.isEnabled !== false,
       channels: Number.isFinite(track?.channels) ? track.channels : null,
+      samplingFrequency: Number.isFinite(track?.samplingFrequency) ? track.samplingFrequency : null,
       // The rate the file STATES for this track, in kbit/s — an average, not a
       // bound — or null where nothing states one (a sidecar read from its
       // container table, a Matroska stream without statistics tags). What a
       // viewer's link is asked to carry for a copied soundtrack is this.
       bitrateKbps: Number.isFinite(track?.bitrateKbps) && track.bitrateKbps > 0 ? track.bitrateKbps : null,
+      codecParameters: track?.codecParameters ?? null,
+      peakKbps: Number.isFinite(track?.peakKbps) && track.peakKbps > 0 ? track.peakKbps : null,
       fileName: kind === "sidecar" ? (file?.name ?? "") : "",
       folders: kind === "sidecar" && Array.isArray(file?.folders) ? file.folders : [],
       // What the file's own path says, for a track that ships as its own file:
@@ -177,15 +187,59 @@ export function enrichAudioInventoryFromSidecar(inventory, file, declaredTrack)
     videoFileIndex: -1,
     sidecars: [{ file, tracks: [declaredTrack] }]
   })[0];
-  Object.assign(current, enriched, {
-    index: current.index,
-    fileIndex: current.fileIndex,
-    sourceTrackIndex: current.sourceTrackIndex,
-    kind: current.kind
-  });
+  Object.assign(current, mergeInventoryEntry(current, enriched));
   return true;
 }
 
+/**
+ * One entry of the inventory with what a later reading of the same track adds.
+ *
+ * Two rules, because the fields are of two kinds:
+ *
+ * 1. a single fact — a language, a title, a flag, a stated average rate — is
+ *    taken from the new reading where it states one, and otherwise the value
+ *    already known stands. A reading that says nothing about a field is not a
+ *    statement that the field is empty;
+ * 2. the codec's configuration is one statement, and the bound is computed from
+ *    it, so its fields are never mixed between readings. A complete set that
+ *    agrees with what is known replaces it whole; an incomplete one that agrees
+ *    leaves it standing; any contradiction — a field both readings state,
+ *    stated differently — withdraws the configuration and the bound, even
+ *    when the new reading is complete, since two readings that disagree
+ *    establish neither. The next complete reading then stands on its own.
+ *
+ * Where the track IS — its number, its file, its position in that file and
+ * whether it is a sidecar — is never changed: a player addresses it by them.
+ *
+ * @param {AudioInventoryEntry} current
+ * @param {AudioInventoryEntry} next
+ * @returns {AudioInventoryEntry}
+ */
+export function mergeInventoryEntry(current, next) {
+  const stated = (value) =>
+    value !== null && value !== undefined && !(typeof value === "string" && value.length === 0);
+  const merged = { ...current };
+  for (const [field, value] of Object.entries(next)) {
+    if (field === "codecParameters" || field === "peakKbps") continue;
+    if (stated(value)) merged[field] = value;
+  }
+  const known = current.codecParameters ?? null;
+  const read = next.codecParameters ?? null;
+  if (codecParametersConflict(known, read)) {
+    merged.codecParameters = null;
+  } else if (codecParametersComplete(read)) {
+    merged.codecParameters = read;
+  } else {
+    merged.codecParameters = known;
+  }
+  merged.peakKbps = peakKbpsOf(merged.codecParameters);
+  merged.index = current.index;
+  merged.fileIndex = current.fileIndex;
+  merged.sourceTrackIndex = current.sourceTrackIndex;
+  merged.kind = current.kind;
+  return merged;
+}
+
 /**
  * The name an `#EXT-X-MEDIA` line carries for one soundtrack.
  *

package/services/media/container/Container.js

@@ -331,6 +331,10 @@ export class Container {
         declaresDefault: track.declaresDefault === true,
         languageBcp47: typeof track.languageBcp47 === "string" ? track.languageBcp47 : "",
         channels: Number.isFinite(track.channels) ? track.channels : null,
+        // The codec's configuration and the most it allows the track to
+        // carry, both as the container states them (`tracks/audio-bound.js`).
+        codecParameters: track.codecParameters ?? null,
+        peakKbps: Number.isFinite(track.peakKbps) && track.peakKbps > 0 ? track.peakKbps : null,
         title:
           typeof banner?.title === "string" && banner.title.length > 0
             ? banner.title
@@ -343,7 +347,9 @@ export class Container {
         isVisualImpaired: false,
         isEnabled: true,
         languageBcp47: "",
-        channels: null
+        channels: null,
+        codecParameters: null,
+        peakKbps: null
       }
     );
   }

package/services/media/container/Mp4Container.js

@@ -88,6 +88,98 @@ function childOf(buf, s, e, t) {
   return childrenOf(buf, s, e, t)[0] ?? null;
 }
 
+/**
+ * The channel count, sampling frequency and decoder configuration one audio
+ * sample entry states (ISO/IEC 14496-12 §12.2.3, AudioSampleEntry).
+ *
+ * After the 8 bytes every SampleEntry begins with come 8 reserved bytes —
+ * whose first two QuickTime uses as a version that lengthens the entry by 16
+ * (version 1) or 36 (version 2) bytes — then `channelcount`, `samplesize`, two
+ * reserved fields and `samplerate` as 16.16 fixed point. Child boxes follow.
+ * For `mp4a` the child `esds` holds the AudioSpecificConfig (ISO/IEC 14496-1
+ * §7.2.6: ES_Descriptor, then DecoderConfigDescriptor, then
+ * DecoderSpecificInfo).
+ *
+ * @param {Buffer} buf
+ * @param {{ type: string, dataOffset: number, end: number }} entry
+ * @returns {{ channels: number | null, sampleRate: number | null, decoderConfig: Buffer | null } | null}
+ */
+function readAudioSampleEntry(buf, entry) {
+  const base = entry.dataOffset;
+  if (base + 28 > entry.end || base + 28 > buf.length) {
+    return null;
+  }
+  const version = buf.readUInt16BE(base + 8);
+  const channels = buf.readUInt16BE(base + 16);
+  const sampleRate = buf.readUInt32BE(base + 24) / 65536;
+  const childrenStart = base + 28 + (version === 1 ? 16 : version === 2 ? 36 : 0);
+  let decoderConfig = null;
+  if (entry.type === "mp4a" && childrenStart < entry.end) {
+    const esds = childOf(buf, childrenStart, Math.min(entry.end, buf.length), "esds");
+    if (esds) {
+      decoderConfig = decoderSpecificInfoOf(buf, esds.dataOffset + 4, Math.min(esds.end, buf.length));
+    }
+  }
+  return {
+    channels: channels > 0 ? channels : null,
+    sampleRate: sampleRate > 0 ? sampleRate : null,
+    decoderConfig
+  };
+}
+
+/**
+ * The DecoderSpecificInfo inside an `esds` payload, or null.
+ *
+ * Descriptors are a tag byte and a size of one to four bytes, seven bits each,
+ * the high bit saying another follows (ISO/IEC 14496-1 §8.3.3).
+ *
+ * @param {Buffer} buf
+ * @param {number} start
+ * @param {number} end
+ * @returns {Buffer | null}
+ */
+function decoderSpecificInfoOf(buf, start, end) {
+  const descriptorAt = (offset) => {
+    if (offset >= end) return null;
+    const tag = buf[offset];
+    let size = 0;
+    let cursor = offset + 1;
+    for (let i = 0; i < 4 && cursor < end; i += 1) {
+      const byte = buf[cursor];
+      cursor += 1;
+      size = (size * 128) + (byte & 0x7f);
+      if ((byte & 0x80) === 0) break;
+    }
+    return { tag, dataOffset: cursor, end: Math.min(end, cursor + size) };
+  };
+  const es = descriptorAt(start);
+  if (!es || es.tag !== 0x03 || es.dataOffset + 3 > es.end) return null;
+  const flags = buf[es.dataOffset + 2];
+  let cursor = es.dataOffset + 3;
+  if (flags & 0x80) cursor += 2;
+  if (flags & 0x40) cursor += 1 + (buf[cursor] ?? 0);
+  if (flags & 0x20) cursor += 2;
+  while (cursor < es.end) {
+    const descriptor = descriptorAt(cursor);
+    if (!descriptor) return null;
+    if (descriptor.tag === 0x04) {
+      // objectTypeIndication, streamType, bufferSizeDB, maxBitrate, avgBitrate.
+      let inner = descriptor.dataOffset + 13;
+      while (inner < descriptor.end) {
+        const child = descriptorAt(inner);
+        if (!child) return null;
+        if (child.tag === 0x05) {
+          return child.end > child.dataOffset ? Buffer.from(buf.subarray(child.dataOffset, child.end)) : null;
+        }
+        inner = child.end;
+      }
+      return null;
+    }
+    cursor = descriptor.end;
+  }
+  return null;
+}
+
 export class Mp4Container extends Container {
   get formatName() {
     return "mp4";
@@ -470,12 +562,16 @@ export class Mp4Container extends Container {
       } else if (handler === "soun") {
         audioIdx += 1;
         let codecId = "";
+        let sampleEntry = null;
         const minf = childOf(moov, mdia.dataOffset, mdia.end, "minf");
         const stbl = minf && childOf(moov, minf.dataOffset, minf.end, "stbl");
         const stsd = stbl && childOf(moov, stbl.dataOffset, stbl.end, "stsd");
         if (stsd) {
           const first = readBox(moov, stsd.dataOffset + 8);
-          if (first) codecId = first.type;
+          if (first) {
+            codecId = first.type;
+            sampleEntry = readAudioSampleEntry(moov, first);
+          }
         }
         result.push(new AudioTrack({
           trackNumber: trackId,
@@ -487,11 +583,15 @@ export class Mp4Container extends Container {
           isEnabled,
           isDefault: true,
           declaresDefault: false,
-          codecPrivateB64: "",
+          // The AudioSpecificConfig an `mp4a` entry carries in its `esds`, which
+          // is what Matroska writes as CodecPrivate for the same codec.
+          codecPrivateB64: sampleEntry?.decoderConfig ? sampleEntry.decoderConfig.toString("base64") : "",
           alternateGroup,
           isOriginal: false,
           isCommentary: false,
-          isVisualImpaired: false
+          isVisualImpaired: false,
+          channels: sampleEntry?.channels ?? null,
+          samplingFrequency: sampleEntry?.sampleRate ?? null
         }));
       }
     }

package/services/media/tracks/AudioTrack.js

@@ -10,6 +10,7 @@
  * MP4 ISO/IEC 14496-12: tkhd alternate_group groups alternate audio tracks.
  */
 
+import { codecParametersOf, peakKbpsOf } from "./audio-bound.js";
 import { ContainerTrack } from "./ContainerTrack.js";
 
 /**
@@ -85,6 +86,17 @@ export class AudioTrack extends ContainerTrack {
     this.isVisualImpaired = params.isVisualImpaired === true;
     this.channels = Number.isFinite(params.channels) ? params.channels : null;
     this.samplingFrequency = Number.isFinite(params.samplingFrequency) ? params.samplingFrequency : null;
+    // What the codec is configured as, and the most that configuration allows
+    // the track to carry — a statement of the file, read with the rest of the
+    // track table (`audio-bound.js`). Own properties rather than getters, so a
+    // copy of the track made field by field keeps them.
+    this.codecParameters = codecParametersOf({
+      codec: AudioTrack.codecNameOf(params),
+      codecPrivateB64: params.codecPrivateB64,
+      channels: this.channels,
+      samplingFrequency: this.samplingFrequency
+    });
+    this.peakKbps = peakKbpsOf(this.codecParameters);
   }
 
   /**