@torrent-tv/proxy 2.88.3 → 2.88.5

package/scripts/build-audio-samples.mjs

@@ -0,0 +1,31 @@
+/** Build-time only. No sample generation runs when the proxy starts. */
+import { spawnSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const directory = fileURLToPath(new URL("../assets/calibration/audio/", import.meta.url));
+const formats = [
+  ["aac", "aac", "m4a"], ["ac3", "ac3", "ac3"], ["eac3", "eac3", "eac3"],
+  ["dts", "dca", "dts"], ["flac", "flac", "flac"], ["opus", "libopus", "opus"],
+  ["vorbis", "libvorbis", "ogg"], ["truehd", "truehd", "thd"], ["mp3", "libmp3lame", "mp3"],
+  ["mp2", "mp2", "mp2"], ["alac", "alac", "m4a"], ["pcm", "pcm_s16le", "wav"]
+];
+mkdirSync(directory, { recursive: true });
+const manifest = [];
+for (const [codec, encoder, extension] of formats) {
+  const file = `${codec}.${extension}`;
+  const result = spawnSync("ffmpeg", ["-hide_banner", "-loglevel", "error", "-y",
+    "-f", "lavfi", "-i", "anoisesrc=color=pink:seed=1:sample_rate=48000",
+    "-t", "4", "-ac", "2", "-strict", "-2", "-c:a", encoder, path.join(directory, file)],
+  { encoding: "utf8", windowsHide: true });
+  if (result.status !== 0) throw new Error(`${codec}: ${result.stderr}`);
+  const probe = spawnSync("ffprobe", ["-v", "error", "-show_streams", "-show_format", "-of", "json",
+    path.join(directory, file)], { encoding: "utf8", windowsHide: true });
+  if (probe.status !== 0) throw new Error(`${codec}: ${probe.stderr}`);
+  const { streams, format } = JSON.parse(probe.stdout);
+  const stream = streams.find(({ codec_type }) => codec_type === "audio");
+  manifest.push({ codec, file, durationSeconds: Number(format.duration), channels: stream.channels,
+    samplingFrequency: Number(stream.sample_rate), bytes: Number(format.size) });
+}
+writeFileSync(path.join(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);

package/server.js

@@ -58,6 +58,7 @@ import { detectVideoEncoder, benchmarkDecodeCost, benchmarkContention, benchmark
 import { calibrateEncoder, HostCalibration } from "./services/encode/calibration.js";
 import { readHostFingerprint } from "./services/encode/fingerprint.js";
 import { measureStartAndStop } from "./services/encode/start-stop-cost.js";
+import { benchmarkAudio } from "./services/encode/audio-calibration.js";
 import { logger } from "./utils/logger.js";
 import { completedFilesRoot } from "./services/storage/files/CompletedFiles.js";
 
@@ -232,6 +233,9 @@ export async function startProxyServer({
   const copySpeedX = transcodeAudio
     ? await benchmarkCopySpeed({ ffmpegBin, logger })
     : null;
+  const audioCalibration = transcodeAudio
+    ? await benchmarkAudio({ ffmpegBin, logger })
+    : [];
   // WHAT A START AND A STOP COST HERE, before any viewer exists. Both decide one
   // thing — leave an encoder where it stands, or kill it and start another —
   // and both used to be learned only from runs that had ENDED, so at a cold
@@ -424,6 +428,7 @@ export async function startProxyServer({
     localPort: selectedPort,
     videoEncoder,
     calibration,
+    audioCalibration,
     decodeCostModel,
     contentionPenalties,
     copySpeedX,

package/services/encode/EncodeRuns.js

@@ -836,7 +836,9 @@ export class EncodeRuns {
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
         if (Number.isInteger(index) && index < safeIndex) return null;
-        return this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat);
+        return this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat, {
+          endSeconds: index < session.timeline.segmentCount - 1 ? session.timeline.publishedStartOf(index + 1) : undefined
+        });
       },
       onEnded: (ended) => this.noteRunEnded(session, run, ended)
     });

package/services/encode/OutputOpening.js

@@ -25,8 +25,7 @@ import { formatSeconds } from "./EncodeRuns.js";
 import { EncodedOutput } from "./output/EncodedOutput.js";
 import { decideOutputFormat } from "./quality/output-format.js";
 import { rungForVisiblePicture } from "./quality/visible-rung.js";
-import { audioLoadOf, linkAnswerFigures as linkFiguresOf } from "./quality/link-budget.js";
-import { AUDIO_TRANSCODE_KBPS } from "./args.js";
+import { SOUNDTRACK_MODE_CAUSE, chooseSoundtrackMode, linkAnswerFigures as linkFiguresOf, soundtrackLoadOf } from "./quality/link-budget.js";
 
 /**
  * @typedef {Object} SegmentOutputFiles
@@ -166,7 +165,7 @@ export class OutputOpening {
     // own. Part of the output's identity: another limit is another output.
     capKbps = null,
     // The soundtrack THIS viewer receives with the picture — from this output
-    // or beside it — as `{ transcode, bitrateKbps }`. Left out, the one this
+    // or beside it — as `{ transcode, entry }`. Left out, the one this
     // request names is theirs. A step opened on a viewer's behalf passes the
     // track they chose, which need not be the one the picture was opened with.
     viewerAudio = undefined,
@@ -215,9 +214,6 @@ export class OutputOpening {
         : 0;
     const normalizedAudioTrack =
       Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0;
-    // What the requester wants of the sound, handed back so the viewer who
-    // asked can be told apart from another viewer of the same output.
-    const audio = { trackIndex: normalizedAudioTrack, transcode: transcodeAudio === true };
     // Which FILE the chosen soundtrack lives in, and which track it is inside
     // that file. A release often ships its dub as a file of its own beside the
     // picture, and the number that travels between the browser, this route and
@@ -225,6 +221,30 @@ export class OutputOpening {
     // is the one place that resolves it, so nothing downstream carries two
     // vocabularies.
     const audioSource = this.#host.renditions.resolveAudioSource(sourceKey, fileIndex, normalizedAudioTrack);
+    // HOW the soundtrack is produced, decided here, before anything is named by
+    // it, by the rule every choice of a track uses (`chooseSoundtrackMode`):
+    // the request says whether the browser plays the track as it is, and the
+    // inventory whether anything states what a copy of it weighs. A track with
+    // no figure is re-encoded even for a browser that would play it, because a
+    // copy of it is a load no link can be asked about. Whatever is decided is
+    // what the output IS — its key, its ffmpeg arguments, the link's question —
+    // and what the viewer is recorded as receiving.
+    const soundtrackMode = chooseSoundtrackMode({
+      entry: audioSource.entry,
+      browserPlays: transcodeAudio !== true,
+      // Nothing reaches this line on a proxy whose transcoding is off: the
+      // opening refuses every request above, so here re-encoding is allowed.
+      transcodeAllowed: true
+    });
+    const audioTranscoded = soundtrackMode.transcode === true;
+    if (soundtrackMode.cause === SOUNDTRACK_MODE_CAUSE.NO_FIGURE) {
+      this.#host.logger.info(
+        `transcode "${fileName || `file ${fileIndex}`}": audio track ${normalizedAudioTrack} — ${soundtrackMode.cause}; it is sent as AAC`
+      );
+    }
+    // What the requester receives of the sound, handed back so the viewer who
+    // asked can be told apart from another viewer of the same output.
+    const audio = { trackIndex: normalizedAudioTrack, transcode: audioTranscoded };
     // The file itself, held once for every session of it. Its name, its key and
     // the facts a probe of it returned used to be copied onto each session, so
     // two viewers of one film held two copies of numbers that cannot differ —
@@ -579,12 +599,9 @@ export class OutputOpening {
       tonemap: applyTonemap,
       capKbps,
       limitsFor: (frame) => this.#host.limitsFor(frame),
-      audioLoad: audioLoadOf(
-        viewerAudio !== undefined
-          ? viewerAudio
-          : { transcode: transcodeAudio === true, bitrateKbps: audioSource.bitrateKbps ?? null },
-        AUDIO_TRANSCODE_KBPS
-      ),
+      audioLoad: viewerAudio !== undefined
+        ? soundtrackLoadOf(viewerAudio?.entry ?? null, viewerAudio ? viewerAudio.transcode : null)
+        : soundtrackLoadOf(audioSource.entry, audioTranscoded),
       specWith: (encode) => new OutputSpec({
         sourceKey,
         segmentFormatId: segmentFormat.id,
@@ -593,7 +610,7 @@ export class OutputOpening {
         grid: new CutGrid({ kind: useKeyframeGrid ? "keyframe" : "uniform", fileIndex }),
         video: carriesVideo ? new VideoOutput({ fileIndex, encode }) : null,
         audio: carriesAudio
-          ? new AudioOutput({ fileIndex: audioSource.fileIndex, trackIndex: audioSource.sourceTrackIndex, transcode: transcodeAudio === true })
+          ? new AudioOutput({ fileIndex: audioSource.fileIndex, trackIndex: audioSource.sourceTrackIndex, transcode: audioTranscoded })
           : null
       }),
       serving: {
@@ -617,7 +634,15 @@ export class OutputOpening {
       error.code = decided.unavailable.bound === "machine" && typeof claim === "function"
         ? OUTPUT_NO_CAPACITY
         : OUTPUT_UNAVAILABLE;
-      error.details = { reason: decided.unavailable.reason, figures: decided.unavailable.figures, wantedKey: decided.wantedKey };
+      error.details = {
+        reason: decided.unavailable.reason,
+        // How many soundtracks the viewer could choose instead, so the page can
+        // offer another one only where there is one to offer.
+        figures: decided.unavailable.figures
+          ? { ...decided.unavailable.figures, soundtracks: this.#host.renditions.offeredSoundtrackCount(sourceKey, fileIndex) }
+          : null,
+        wantedKey: decided.wantedKey
+      };
       throw error;
     }
     if (decided.answer) {
@@ -723,7 +748,7 @@ export class OutputOpening {
         // side saying what it meant is why that took three attempts to place.
         `start=${Math.round(normalizedStartPosition)}s ` +
         `video=${transcodeVideo ? `${this.#host.videoEncoder.name}${output.softwarePreset ? `/${output.softwarePreset}` : ""}` : "copy"} ` +
-        `audio=${transcodeAudio ? "aac" : "copy"} ` +
+        `audio=${audioTranscoded ? "aac" : "copy"} ` +
         // Branch tag for log correlation: A = video re-encode (fixed GOP, grid
         // aligned, ts-offset); B = video copy (cut at source keyframes, copyts).
         `branch=${transcodeVideo ? "A(reencode,fixed-gop)" : "B(copy,copyts)"} ` +

package/services/encode/Renditions.js

@@ -12,8 +12,8 @@ import { isOutputName, OUTPUT_UNAVAILABLE } from "./output/index.js";
 import { masterPlaylistText, PLAYLIST_FILE_NAME } from "./output/playlists.js";
 import { variantHeightsFor } from "./output/ladder.js";
 import { isSameMaterial, outputSuits } from "./quality/serving-output.js";
-import { audioLoadOf, linkAnswerFigures, linkCouldCarry, loadOf, videoLoadOfLimit, videoLoadOfSpec } from "./quality/link-budget.js";
-import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor } from "./args.js";
+import { SOUNDTRACK_MODE_CAUSE, chooseSoundtrackMode, linkAnswerFigures, linkCouldCarry, loadOf, soundtrackLoadOf, videoLoadOfLimit, videoLoadOfSpec } from "./quality/link-budget.js";
+import { maxrateKbpsFor } from "./args.js";
 import { encoderInputs } from "./run-inputs.js";
 /**
  * How a base files the audio renditions it has made.
@@ -120,7 +120,7 @@ export class Renditions {
    */
   #suitsViewer(output, base, consumerId, wanted = null) {
     const linkMbps = this.#host.linkMbpsOf(base, consumerId);
-    const audioLoad = audioLoadOf(this.#viewerAudioOf(base, consumerId), AUDIO_TRANSCODE_KBPS);
+    const audioLoad = this.viewerAudioLoadOf(base, consumerId);
     const encode = output.spec?.video?.encode ?? null;
     return outputSuits({
       spec: output.spec,
@@ -145,33 +145,114 @@ export class Renditions {
    * @returns {import("./quality/link-budget.js").LoadPart | null}
    */
   viewerAudioLoadOf(base, consumerId) {
-    return audioLoadOf(this.#viewerAudioOf(base, consumerId), AUDIO_TRANSCODE_KBPS);
+    const audio = this.#viewerAudioOf(base, consumerId);
+    return soundtrackLoadOf(audio.entry, audio.transcode);
   }
 
   /**
    * The soundtrack THIS viewer receives with the picture, as the link sees it:
-   * whether it is re-encoded, and the rate the file states for it.
+   * the mode it is produced in, and the inventory entry that says what it
+   * weighs.
    *
    * Their own choice where they have made one, else the picture's own track.
-   * Counted whether it travels inside the picture or as a stream of its own:
-   * it crosses the same link either way.
+   * The mode is the one recorded when they chose it — what they are actually
+   * sent — and is NOT decided again here: a later reading that gives a track a
+   * figure changes the decision for the next choice, not the soundtrack
+   * already reaching them. Counted whether it travels inside the picture or as
+   * a stream of its own: it crosses the same link either way.
    *
    * @param {HlsSession} base
    * @param {string} consumerId
-   * @returns {{ transcode: boolean, bitrateKbps: number | null }}
+   * @returns {{ transcode: boolean, entry: object | null }}
    */
   #viewerAudioOf(base, consumerId) {
     const choice = this.#host.audioChoiceOf(base, consumerId) ??
       { trackIndex: this.#flatAudioTrackOf(base), transcode: base.spec.transcodesAudio };
+    return {
+      transcode: choice.transcode === true,
+      entry: this.#audioEntryOf(base, choice.trackIndex)
+    };
+  }
+
+  /**
+   * The soundtrack this viewer is recorded as receiving with this picture, and
+   * whether it reaches them re-encoded.
+   *
+   * @param {HlsSession} base
+   * @param {string} consumerId
+   * @returns {{ trackIndex: number, transcode: boolean }}
+   */
+  soundtrackOf(base, consumerId) {
+    const choice = this.#audioChoiceOf(base, consumerId);
+    return { trackIndex: choice.trackIndex, transcode: choice.transcode === true };
+  }
+
+  /**
+   * How many soundtracks a viewer of this file can choose between: the
+   * inventory's tracks, less those the container marks unusable, which the
+   * page leaves out of its menu.
+   *
+   * @param {string} sourceKey
+   * @param {number} fileIndex - The PICTURE's file.
+   * @returns {number}
+   */
+  offeredSoundtrackCount(sourceKey, fileIndex) {
+    const inventory = this.#host.getCachedAudioTracks?.({ sourceKey, fileIndex }) ?? [];
+    return Array.isArray(inventory) ? inventory.filter((entry) => entry?.isEnabled !== false).length : 0;
+  }
+
+  /**
+   * One soundtrack's entry in the inventory of this picture's file, or null.
+   *
+   * @param {HlsSession} base
+   * @param {number} trackIndex
+   * @returns {object | null}
+   */
+  #audioEntryOf(base, trackIndex) {
     const inventory = this.#host.getCachedAudioTracks?.({
       sourceKey: base.file.sourceKey,
       fileIndex: base.file.fileIndex
     }) ?? [];
-    const entry = Array.isArray(inventory) ? inventory.find((one) => one?.index === choice.trackIndex) : null;
-    return {
-      transcode: choice.transcode === true,
-      bitrateKbps: Number.isFinite(entry?.bitrateKbps) ? entry.bitrateKbps : null
-    };
+    return Array.isArray(inventory) ? (inventory.find((one) => one?.index === trackIndex) ?? null) : null;
+  }
+
+  /**
+   * How a soundtrack is produced for this viewer, when they move to it.
+   *
+   * Decided by the rule every choice of a track uses (`chooseSoundtrackMode`).
+   * What their browser can play is what the page states for THAT track when it
+   * prepares the switch; a page that states nothing is taken to need what it
+   * needed for the track it is on — what every switch assumed before a page
+   * could say. A track being prepared for them, or already theirs, keeps the
+   * mode it was given, so the files of one switch all come from one output.
+   *
+   * @param {HlsSession} base
+   * @param {string} consumerId
+   * @param {number} trackIndex
+   * @param {boolean | null} [browserPlays] - What the page stated, or null.
+   * @returns {boolean | null} Whether to re-encode it; null when it cannot be
+   *   served.
+   */
+  #audioModeFor(base, consumerId, trackIndex, browserPlays = null) {
+    const choice = this.#audioChoiceOf(base, consumerId);
+    if (browserPlays === null) {
+      const warming = this.#host.outputs.get(this.#host.audioBeingWarmedOf(base, consumerId) ?? "");
+      if (warming && this.#flatAudioTrackOf(warming) === trackIndex) {
+        return warming.spec.transcodesAudio;
+      }
+      if (choice.trackIndex === trackIndex) {
+        return choice.transcode;
+      }
+    }
+    const decided = chooseSoundtrackMode({
+      entry: this.#audioEntryOf(base, trackIndex),
+      browserPlays: browserPlays ?? !choice.transcode,
+      transcodeAllowed: this.#host.transcodeEnabled !== false
+    });
+    if (decided.cause === SOUNDTRACK_MODE_CAUSE.NO_FIGURE) {
+      this.#host.logger.info(`transcode ${base.id} audio track ${trackIndex}: ${decided.cause}; it is sent as AAC`);
+    }
+    return decided.transcode;
   }
 
   async resolveVariantSession(baseSessionId, height, wantedIndex = -1, consumerId = "") {
@@ -1206,9 +1287,12 @@ export class Renditions {
    * @param {string} baseSessionId
    * @param {number} trackIndex
    * @param {number} positionSeconds
+   * @param {string} consumerId
+   * @param {boolean | null} [browserPlays] - Whether the page states its browser
+   *   plays this track as it is; null when it does not say.
    * @returns {Promise<{ sessionId: string, fileName: string } | null>}
    */
-  async prepareAudioTrack(baseSessionId, trackIndex, positionSeconds, consumerId) {
+  async prepareAudioTrack(baseSessionId, trackIndex, positionSeconds, consumerId, browserPlays = null) {
     const base = this.#host.outputs.get(baseSessionId);
     // A track is prepared FOR somebody; a request naming nobody prepares nothing.
     if (!consumerId || !base || !this.servesAudioSeparately(base)) {
@@ -1217,7 +1301,7 @@ export class Renditions {
     if (!this.#audioRenditionsOf(base).some((track) => track.trackIndex === trackIndex)) {
       return null;
     }
-    const rendition = await this.#resolveAudioRenditionSession(base, trackIndex, consumerId);
+    const rendition = await this.#resolveAudioRenditionSession(base, trackIndex, consumerId, browserPlays);
     if (!rendition) {
       return null;
     }
@@ -1657,7 +1741,7 @@ export class Renditions {
       this.#host.placeViewerOn(rendition, consumerId, this.#host.viewerPositionOf(base.id, consumerId));
     }
     if (isSegment && rendition) {
-      this.#noteAudioTrackActive(base, trackIndex, consumerId);
+      this.#noteAudioTrackActive(base, rendition, consumerId);
     }
     return { sessionId: rendition?.id ?? null };
   }
@@ -1685,20 +1769,26 @@ export class Renditions {
    * and stopping "the others" per request would have them switch each other's
    * soundtrack off in turn, once per segment, for the whole film.
    *
+   * What is recorded is the soundtrack they are SENT — its track and the mode
+   * the output that serves it is produced in — so every later reading of
+   * their load counts the output that actually reaches them.
+   *
    * @param {HlsSession} base
-   * @param {number} trackIndex
+   * @param {HlsSession} rendition - The output the segment came from.
    * @param {string} consumerId - Who is listening. A request that names
    *   nobody changes nobody's track.
    */
-  #noteAudioTrackActive(base, trackIndex, consumerId) {
+  #noteAudioTrackActive(base, rendition, consumerId) {
     if (!consumerId) {
       return;
     }
+    const trackIndex = this.#flatAudioTrackOf(rendition);
+    const transcode = rendition.spec.transcodesAudio === true;
     const previous = this.#audioChoiceOf(base, consumerId);
-    if (previous.trackIndex === trackIndex) {
+    if (previous.trackIndex === trackIndex && previous.transcode === transcode) {
       return;
     }
-    this.#host.chooseAudioTrack(base, consumerId, { ...previous, trackIndex });
+    this.#host.chooseAudioTrack(base, consumerId, { trackIndex, transcode });
     // Every soundtrack nobody present is listening to any more stops being
     // waited on.
     const wanted = this.#liveAudioRenditionKeys(base);
@@ -1800,17 +1890,23 @@ export class Renditions {
    *
    * Filed under the track AND how it has to be produced, because those are two
    * different encodes: a browser that can decode this track as it stands is
-   * served a copy, and one that cannot is served AAC. The base cannot answer
-   * for either of them now that it is shared — its own `transcodeAudio` is
-   * whatever the first viewer's browser needed.
+   * served a copy, and one that cannot is served AAC — and so is a track with
+   * no stated rate, whose copy the viewer's link could not be asked about. The
+   * base cannot answer for either of them now that it is shared — its own
+   * `transcodeAudio` is whatever the first viewer's browser needed.
    *
    * @param {HlsSession} base
    * @param {number} trackIndex
    * @param {string} consumerId - Who is asking.
-   * @returns {Promise<HlsSession | null>}
+   * @param {boolean | null} [browserPlays] - What the page stated, or null.
+   * @returns {Promise<HlsSession | null>} Null as well when the track cannot be
+   *   served to this viewer at all.
    */
-  async #resolveAudioRenditionSession(base, trackIndex, consumerId = "") {
-    const transcodeAudio = this.#audioChoiceOf(base, consumerId).transcode;
+  async #resolveAudioRenditionSession(base, trackIndex, consumerId = "", browserPlays = null) {
+    const transcodeAudio = this.#audioModeFor(base, consumerId, trackIndex, browserPlays);
+    if (transcodeAudio === null) {
+      return null;
+    }
     // Found by what it IS: a soundtrack of this file, this track, produced this
     // way. That is what a map from a rendition key to a session id said, at the
     // price of a link between two sessions' lifetimes — one that had to be
@@ -1945,7 +2041,7 @@ export class Renditions {
    * @param {string} sourceKey
    * @param {number} fileIndex - The PICTURE's file.
    * @param {number} flatIndex
-   * @returns {{ fileIndex: number, sourceTrackIndex: number, isSidecar: boolean, name: string }}
+   * @returns {{ fileIndex: number, sourceTrackIndex: number, isSidecar: boolean, name: string, entry: object | null }}
    */
   resolveAudioSource(sourceKey, fileIndex, flatIndex) {
     const inventory = this.#host.getCachedAudioTracks?.({ sourceKey, fileIndex }) ?? [];
@@ -1953,16 +2049,18 @@ export class Renditions {
       ? inventory.find((candidate) => candidate?.index === flatIndex)
       : null;
     if (!entry || !Number.isInteger(entry.fileIndex) || !Number.isInteger(entry.sourceTrackIndex)) {
-      return { fileIndex, sourceTrackIndex: flatIndex, isSidecar: false, name: "" };
+      return { fileIndex, sourceTrackIndex: flatIndex, isSidecar: false, name: "", entry: null };
     }
     return {
       fileIndex: entry.fileIndex,
       sourceTrackIndex: entry.sourceTrackIndex,
       isSidecar: entry.fileIndex !== fileIndex,
       name: typeof entry.fileName === "string" ? entry.fileName : "",
-      // The rate the file states for this track, or null; what a viewer's link
-      // is asked to carry for it when it is copied.
-      bitrateKbps: Number.isFinite(entry.bitrateKbps) ? entry.bitrateKbps : null
+      // The whole entry, which is what says what the track weighs on a link —
+      // the bound its codec allows, the rate the file states — and decides how
+      // it is produced. Handed on whole, so no conversion between here and the
+      // link's question can drop a field of it.
+      entry
     };
   }
 

package/services/encode/args.js

@@ -87,9 +87,11 @@ const NOMINAL_KBPS_BY_ROW = new Map([
 // written down beside it.
 const ROW_REFERENCE_SOURCE = Object.freeze({ width: 3840, height: 2160 });
 /**
- * The rate a re-encoded soundtrack is produced at, in kbit/s: stereo AAC,
- * constant. Stated once because two places need the same figure — the ffmpeg
- * arguments that produce it, and the viewer's link that has to carry it.
+ * The rate a re-encoded soundtrack is asked for, in kbit/s: stereo AAC. A
+ * TARGET, not a bound — ffmpeg's AAC encoder lets single frames run above it
+ * from its bit reservoir. Stated once because two places need the same figure —
+ * the ffmpeg arguments that ask for it, and the viewer's link that has to carry
+ * it, which counts it as an estimate (`quality/link-budget.js`).
  */
 export const AUDIO_TRANSCODE_KBPS = 128;
 const CAP_MAXRATE_FACTOR = 1.3;

package/services/encode/audio-calibration.js

@@ -0,0 +1,67 @@
+/** Short startup measurements of packaged audio samples. */
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { AUDIO_TRANSCODE_KBPS } from "./args.js";
+import { ENCODE_BENCHMARK_TIMEOUT_MS } from "./hwaccel.js";
+
+const SAMPLE_DIRECTORY = fileURLToPath(new URL("../../assets/calibration/audio/", import.meta.url));
+
+function measure(ffmpegBin, file, operation, signal) {
+  return new Promise((resolve) => {
+    const startedAt = performance.now();
+    let mediaSeconds = 0;
+    let text = "";
+    let diagnostics = "";
+    const child = spawn(ffmpegBin, ["-hide_banner", "-loglevel", "info", "-nostats", "-benchmark",
+      "-i", file, "-map", "0:a:0", "-vn", "-c:a", operation,
+      ...(operation === "aac" ? ["-b:a", `${AUDIO_TRANSCODE_KBPS}k`, "-ac", "2"] : []),
+      "-f", "null", "-", "-progress", "pipe:1"],
+    { stdio: ["ignore", "pipe", "pipe"], windowsHide: true,
+      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(ENCODE_BENCHMARK_TIMEOUT_MS)]) :
+        AbortSignal.timeout(ENCODE_BENCHMARK_TIMEOUT_MS) });
+    child.stdout.on("data", (data) => {
+      text += String(data);
+      const rows = text.split("\n");
+      text = rows.pop();
+      for (const row of rows) {
+        if (row.startsWith("out_time_us=")) {
+          const value = Number(row.slice("out_time_us=".length)) / 1e6;
+          if (Number.isFinite(value) && value > 0) mediaSeconds = value;
+        }
+      }
+    });
+    child.stderr.on("data", (data) => { diagnostics += String(data); });
+    child.on("error", () => resolve(null));
+    child.on("close", (code) => {
+      const elapsed = (performance.now() - startedAt) / 1000;
+      const runtime = diagnostics.match(/bench:.*rtime=(\d+\.(\d+))s/);
+      // The reported decimal precision bounds timing uncertainty, including a
+      // runtime printed as zero. This is a clock-resolution bound, not a weight.
+      const processingSeconds = runtime ? Number(runtime[1]) + 10 ** -runtime[2].length : null;
+      resolve(code === 0 && mediaSeconds > 0 && processingSeconds > 0 ?
+        { speed: mediaSeconds / processingSeconds, work: mediaSeconds, elapsed, processingSeconds,
+          startupSeconds: Math.max(0, elapsed - processingSeconds) } : null);
+    });
+  });
+}
+
+export async function benchmarkAudio({ ffmpegBin, logger, signal, sampleDirectory = SAMPLE_DIRECTORY }) {
+  const samples = JSON.parse(await readFile(path.join(sampleDirectory, "manifest.json"), "utf8"));
+  const readings = [];
+  const startedAt = performance.now();
+  for (const sample of samples) {
+    for (const operation of ["copy", "aac"]) {
+      if (signal?.aborted) return readings;
+      const reading = await measure(ffmpegBin, path.join(sampleDirectory, sample.file), operation, signal);
+      if (reading) readings.push({ ...sample, operation, ...reading });
+      else logger?.warn(`audio calibration ${sample.codec}->${operation} could not be measured`);
+    }
+  }
+  logger?.info(`audio calibration: ${readings.length} short packaged-sample measurements in ` +
+    `${((performance.now() - startedAt) / 1000).toFixed(2)}s`);
+  return readings;
+}
+
+export { audioReadingFor } from "./audio-work-rate.js";

package/services/encode/audio-work-rate.js

@@ -0,0 +1,15 @@
+/** Initial per-codec work model, replaced by the track's actual speed. */
+export function audioReadingFor(readings, { codec, transcode, channels, samplingFrequency, bitrateKbps }) {
+  const operation = transcode ? "aac" : "copy";
+  const normalized = String(codec ?? "").replace(/^pcm_.*/, "pcm");
+  const reference = readings?.find((reading) => reading.codec === normalized && reading.operation === operation);
+  if (!reference) return null;
+  const referenceBytesPerSecond = reference.bytes / reference.durationSeconds;
+  // Copy work is encoded bytes; processing work is audio samples. Unstated
+  // dimensions retain the reference measurement, rather than invented values.
+  const workRatio = !transcode && bitrateKbps > 0 ? (bitrateKbps * 1000 / 8) / referenceBytesPerSecond :
+    transcode && channels > 0 && samplingFrequency > 0 ?
+      (channels * samplingFrequency) / (reference.channels * reference.samplingFrequency) : 1;
+  return { ...reference, speed: reference.speed / workRatio,
+    basis: workRatio === 1 ? "measured-reference" : transcode ? "audio-samples" : "encoded-bytes" };
+}

package/services/encode/hwaccel.js

@@ -94,7 +94,7 @@ const ENCODE_BENCHMARK_MAX_PLAUSIBLE_SPEED = 1000;
  * A preset that has not reported twice in this long is hung, not slow: reports
  * arrive twice a second whatever the encoding speed.
  */
-const ENCODE_BENCHMARK_TIMEOUT_MS = 10_000;
+export const ENCODE_BENCHMARK_TIMEOUT_MS = 10_000;
 /**
  * How many times the calibration clip is joined to itself to measure copying.
  *

package/services/encode/quality/EncodeCost.js

@@ -65,6 +65,7 @@ import { throughputAt } from "../throughput.js";
 import { computeOutputDimensions, TRANSCODE_FPS } from "../args.js";
 import { logger } from "../../../utils/logger.js";
 import { qualityStateOf } from "./OutputQualityState.js";
+import { audioReadingFor } from "../audio-work-rate.js";
 
 export class EncodeCost {
   /**
@@ -159,11 +160,20 @@ export class EncodeCost {
    * about the machine — and because the offer's cache key needs it too, so a
    * caller that has a session can ask without holding an instance.
    *
-   * @param {{ file: { key: string }, audioTrackIndex?: number }} session
+   * Named by everything that changes what producing it costs: the file the
+   * sound is read from, the track inside that file, and whether it is copied
+   * or re-encoded. One track may be copied for one viewer and re-encoded for
+   * another, and a copy's speed priced an encode it says nothing about; and a
+   * soundtrack shipped as its own file is track 0 of THAT file, which without
+   * the file in the name shared a price with the picture's own track 0.
+   *
+   * @param {{ file: { key: string }, spec?: { audioFileIndex?: number, audioSourceTrackIndex?: number, transcodesAudio?: boolean } }} session
    * @returns {string}
    */
   static audioKeyOf(session) {
-    return `${session.file.key}:${session.spec?.audioSourceTrackIndex ?? 0}`;
+    const spec = session.spec ?? {};
+    return `${session.file.key}:a${spec.audioFileIndex ?? ""}:${spec.audioSourceTrackIndex ?? 0}:` +
+      `${spec.transcodesAudio === true ? "aac" : "copy"}`;
   }
 
   /**
@@ -369,7 +379,14 @@ export class EncodeCost {
     }
     if (session.spec.carries === "audio-only") {
       const audio = this.#audioCost.get(EncodeCost.audioKeyOf(session));
-      return { costSec: audio && audio.costSec > 0 ? audio.costSec : null, fileKey, fileCostSec };
+      const initial = audioReadingFor(this.#host().audioCalibration, {
+        ...this.#host().audioDescriptionOf?.(session),
+        codec: this.#host().audioDescriptionOf?.(session)?.codec ?? session.file.media?.audioCodec,
+        transcode: session.spec.audio?.transcode === true
+      });
+      const initialSpeed = initial?.speed;
+      return { costSec: audio && audio.costSec > 0 ? audio.costSec :
+        initialSpeed > 0 ? 1 / initialSpeed : null, fileKey, fileCostSec };
     }
     if (!session.spec.transcodesVideo) {
       const copy = this.#copyCost.get(session.file.key);
@@ -383,6 +400,15 @@ export class EncodeCost {
     return { costSec: picture > 0 ? picture : null, fileKey, fileCostSec };
   }
 
+  /** A prediction for this operation, using its measured cost and actual contention. */
+  projectedSpeedOf(session) {
+    const load = this.#loadOfSession(session);
+    const others = Math.max(0, this.#runningEncoders() - this.#runsFor(session).length);
+    const { penalty } = contentionPenalty(others, this.#host().contentionPenalties);
+    return load.costSec > 0 ? correctForAvailability(1 / (load.costSec * penalty),
+      this.#host().availability) : null;
+  }
+
   /**
    * What everything OTHER than this session is costing right now, or null when
    * any of it is unpriced.