@torrent-tv/proxy 2.107.58 → 2.107.60

package/package.json

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

package/services/encode/AdmittedInput.js

@@ -5,7 +5,7 @@ import { pcmNormalization, normalizePcmSlices } from "./pcm-normalization.js";
 const INPUT_WRITE_BATCH_BYTES = 64 * 1024;
 
 /** Acquire complete source ranges before any process can consume the input. */
-export async function admitInput({ sources, reserve, readRanges }) {
+export async function admitInput({ sources, reserve, readRanges, matroskaIdOf }) {
   if (!Array.isArray(sources) || sources.length === 0 || typeof reserve !== "function" || typeof readRanges !== "function") {
     throw new TypeError("Admission requires resolved source inputs, memory reservation and an available-only reader.");
   }
@@ -41,7 +41,7 @@ export async function admitInput({ sources, reserve, readRanges }) {
           pts: packet.pts - (source.timeShiftSeconds ?? 0),
           ...(packet.dts === undefined ? {} : { dts: packet.dts - (source.timeShiftSeconds ?? 0) }) })) };
         tracks.push(shifted);
-        hash.update(matroskaTrackIdentity(input.track));
+        hash.update(matroskaTrackIdentity(input.track, matroskaIdOf));
         hash.update(JSON.stringify(shifted.packets.map(packet => [packet.pts, packet.dts ?? null,
           packet.duration, packet.keyframe === true, packet.ranges, packet.discardPaddingSeconds ?? 0,
           packet.bitOffset ?? null, packet.bitLength ?? null])));
@@ -82,8 +82,8 @@ export async function admitInput({ sources, reserve, readRanges }) {
     }
     retained = true;
     return {
-      kind: "result", bytes, fingerprint: hash.digest("hex"), originSeconds, tracks, readPacket,
-      stream: options => matroskaInput({ tracks,
+      kind: "result", matroskaIdOf, bytes, fingerprint: hash.digest("hex"), originSeconds, tracks, readPacket,
+      stream: options => matroskaInput({ tracks, matroskaIdOf,
         readPacket: (input, packet) => normalized.has(packet) ? [normalized.get(packet)] : packetSlices(input, packet),
         originSeconds, ...options }),
       release: () => {
@@ -112,13 +112,13 @@ export async function admitInput({ sources, reserve, readRanges }) {
 export async function writeAdmittedInput(input, stdin, { next = null, waiting = null, onFirstInputBytes = null } = {}) {
   if (input?.kind !== "result") throw new TypeError("Only complete input may be written to an encoder.");
   const originSeconds = input.originSeconds;
-  const declarations = JSON.stringify(input.tracks.map(input => matroskaTrackIdentity(input.track)));
+  const declarations = JSON.stringify(input.tracks.map(track => matroskaTrackIdentity(track.track, input.matroskaIdOf)));
   const seen = new Map();
   let firstInputBytesNoted = false;
   let current = input, includeHeader = true;
   try {
     while (current) {
-      if (JSON.stringify(current.tracks.map(input => matroskaTrackIdentity(input.track))) !== declarations) {
+      if (JSON.stringify(current.tracks.map(track => matroskaTrackIdentity(track.track, current.matroskaIdOf))) !== declarations) {
         throw new Error("Consecutive encoder input changed its declared tracks.");
       }
       for (let index = 0; index < current.tracks.length; index++) {

package/services/encode/EncodeInputs.js

@@ -67,10 +67,12 @@ export class EncodeInputs {
    */
   #stretchCopied;
   #observeWait;
+  #matroskaIdOf;
 
   constructor({ resolve, readRanges, openWholeFile = null, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
     rankAt = () => null, demandChanged = () => {}, openOf = () => null, log = () => {}, now = Date.now, stretchCopied = () => {},
-    observeWait = null }) {
+    observeWait = null, matroskaIdOf }) {
+    this.#matroskaIdOf = matroskaIdOf;
     this.#stretchCopied = stretchCopied;
     this.#observeWait = observeWait;
     this.#openOf = openOf;
@@ -461,7 +463,7 @@ export class EncodeInputs {
         }
         if (!result) return;
       } else {
-        result = await admitInput({ sources: resolved.sources, readRanges: this.#read, reserve: this.#reserveFor(request) });
+        result = await admitInput({ sources: resolved.sources, readRanges: this.#read, matroskaIdOf: this.#matroskaIdOf, reserve: this.#reserveFor(request) });
         if (result.kind === "result") Object.assign(result, { from: request.from, to: request.from });
       }
       if (this.#requests.get(request.key) !== request) { result.release?.(); return; }

package/services/encode/EncodeRuns.js

@@ -1783,19 +1783,32 @@ export class EncodeRuns {
     // disposed. A run that had already finished or failed is not among them,
     // which is what keeps a stop from erasing how it actually ended.
     for (const run of running) {
-      // The run resumes itself if it was suspended — a stopped process does not
-      // act on SIGTERM until it is continued — records the cause, and answers
-      // its own exit. Nothing here has to null a field so that the exit is read
-      // correctly, because there is no shared field left to misread.
-      run.stop(reason);
       // Nothing is cleared up from here. What this run left open is under its
       // own working name, and the encoding layer removes it when the run's
       // ending reaches it — one place, and it needs neither the stretch nor the
       // init bytes this method used to fetch to judge a file by its contents.
+      this.stopRun(run, reason);
     }
     this.#host.logger.info(`transcode ${session.id} ${running.length} encoder(s) stopped: ${reason}`);
   }
 
+  /**
+   * Stop one run, for a stated reason, and nothing else of its output.
+   *
+   * For a caller that knows WHICH run is wrong: an output may hold a second run
+   * near the viewer that is positioned correctly and must keep producing.
+   *
+   * @param {object} run - A live run of this class's.
+   * @param {string} reason - Named in the log.
+   * @returns {void}
+   */
+  stopRun(run, reason) {
+    // The run resumes itself if it was suspended — a stopped process does not
+    // act on SIGTERM until it is continued — records the cause, and answers
+    // its own exit.
+    run.stop(reason);
+  }
+
   /**
    * What moving the encoder BACKWARDS costs, said out loud when it happens.
    *

package/services/encode/MatroskaInput.js

@@ -2,12 +2,12 @@ import { avcPacketSlices } from "./annex-b-input.js";
 import { bitPayloadSlices } from "./bit-payload.js";
 
 /** Emit already admitted packets as one timestamped Matroska input. */
-export async function* matroskaInput({ tracks, readPacket, originSeconds = 0, includeHeader = true, seen = new Map() }) {
+export async function* matroskaInput({ tracks, readPacket, originSeconds = 0, includeHeader = true, seen = new Map(), matroskaIdOf }) {
   if (!Array.isArray(tracks) || tracks.length === 0 || typeof readPacket !== "function" || !Number.isFinite(originSeconds)) {
     throw new TypeError("A Matroska input requires tracks, admitted packets and a timeline origin.");
   }
   if (includeHeader) {
-  const declarations = tracks.map((input, position) => trackElement(input.track, position + 1));
+  const declarations = tracks.map((input, position) => trackElement(input.track, position + 1, matroskaIdOf));
   yield element("1a45dfa3", Buffer.concat([
     uintElement("4286", 1), uintElement("42f7", 1), uintElement("42f2", 4), uintElement("42f3", 8),
     textElement("4282", "matroska"), uintElement("4287", 4), uintElement("4285", 2)
@@ -107,10 +107,10 @@ export async function* matroskaInput({ tracks, readPacket, originSeconds = 0, in
   }
 }
 
-function trackElement(track, number) {
+function trackElement(track, number, matroskaIdOf) {
   const type = track.type === "video" ? 1 : track.type === "audio" ? 2 : null;
   if (type === null) throw new Error("Admitted input carries an unsupported track type.");
-  const codec = track.matroskaCodecId ?? matroskaCodec(track.codecId);
+  const codec = track.matroskaCodecId ?? matroskaCodec(track.codecId, matroskaIdOf);
   const fields = [uintElement("d7", number), uintElement("73c5", number), uintElement("83", type),
     uintElement("9c", 0), textElement("86", codec)];
   const privateBytes = track.matroskaCodecPrivateB64 ?? track.codecPrivateB64;
@@ -133,9 +133,10 @@ function trackElement(track, number) {
 }
 
 /** Stable identity of every declaration emitted into the input stream. */
-export function matroskaTrackIdentity(track) {
+/** @param {(codec: string) => string | undefined} matroskaIdOf - Names a codec's Matroska id; handed in, since this layer reads no other. */
+export function matroskaTrackIdentity(track, matroskaIdOf) {
   return JSON.stringify([
-    track.type, track.matroskaCodecId ?? matroskaCodec(track.codecId),
+    track.type, track.matroskaCodecId ?? matroskaCodec(track.codecId, matroskaIdOf),
     track.matroskaCodecPrivateB64 ?? track.codecPrivateB64 ?? "",
     track.language ?? "", track.packetFraming ?? "", track.width ?? null, track.height ?? null,
     track.samplingFrequency ?? null, track.channels ?? null, track.bitDepth ?? null,
@@ -143,23 +144,9 @@ export function matroskaTrackIdentity(track) {
   ]);
 }
 
-function matroskaCodec(codec) {
-  if (/^[VA]_/.test(codec)) return codec;
-  if (/^pcm_[su](?:16|24|32|64)le$/.test(codec) || /^pcm_[su]8(?:le|be)?$/.test(codec)) return "A_PCM/INT/LIT";
-  if (/^pcm_[su](?:16|24|32|64)be$/.test(codec)) return "A_PCM/INT/BIG";
-  if (/^pcm_f(?:32|64)(?:le|be)$/.test(codec)) return "A_PCM/FLOAT/IEEE";
-  const declared = new Map([
-    ["avc1", "V_MPEG4/ISO/AVC"], ["avc3", "V_MPEG4/ISO/AVC"], ["h264", "V_MPEG4/ISO/AVC"],
-    ["hvc1", "V_MPEGH/ISO/HEVC"], ["hev1", "V_MPEGH/ISO/HEVC"], ["hevc", "V_MPEGH/ISO/HEVC"],
-    ["av01", "V_AV1"], ["av1", "V_AV1"], ["vp9", "V_VP9"], ["vp8", "V_VP8"],
-    ["mjpeg", "V_MJPEG"], ["ffv1", "V_FFV1"], ["theora", "V_THEORA"], ["jpeg2000", "V_JPEG2000"],
-    ["mpeg1video", "V_MPEG1"], ["mpeg2video", "V_MPEG2"], ["mpeg4", "V_MPEG4/ISO/ASP"],
-    ["FMP4", "V_MPEG4/ISO/ASP"], ["XVID", "V_MPEG4/ISO/ASP"], ["DIVX", "V_MPEG4/ISO/ASP"],
-    ["mp4a", "A_AAC"], ["aac", "A_AAC"], ["mp3", "A_MPEG/L3"], ["mp2", "A_MPEG/L2"], ["mp1", "A_MPEG/L1"],
-    ["ac-3", "A_AC3"], ["ac3", "A_AC3"], ["ec-3", "A_EAC3"], ["eac3", "A_EAC3"],
-    ["Opus", "A_OPUS"], ["opus", "A_OPUS"], ["fLaC", "A_FLAC"], ["flac", "A_FLAC"], ["dts", "A_DTS"],
-    ["vorbis", "A_VORBIS"], ["alac", "A_ALAC"], ["truehd", "A_TRUEHD"]
-  ]).get(codec);
+function matroskaCodec(codec, matroskaIdOf) {
+  if (typeof matroskaIdOf !== "function") throw new TypeError("A Matroska input is given the lookup that names codec ids.");
+  const declared = matroskaIdOf(codec);
   if (!declared) throw new Error(`Admitted codec ${codec} has no Matroska declaration.`);
   return declared;
 }

package/services/encode/OutputTimes.js

@@ -98,7 +98,7 @@ export class OutputTimes {
   #host;
 
   /**
-   * @param {object} host - `logger`, `runsOf`, `stopEncodeRun`, `planEncodersSoon`, `outputs`, `segmentDurationSec`
+   * @param {object} host - `logger`, `runsOf`, `stopRun`, `planEncodersSoon`, `outputs`, `segmentDurationSec`
    */
   constructor(host) {
     this.#host = host;
@@ -454,7 +454,8 @@ export class OutputTimes {
     // claimed. It converges: once the boundary holds the true time, the next
     // reading agrees with it and the guard above returns before doing anything.
     for (const member of this.#host.outputs.familyOf(session)) {
-      if (member === session || runStartingAt(this.#host.runsOf(member), index) === null) {
+      const misplaced = member === session ? null : runStartingAt(this.#host.runsOf(member), index);
+      if (misplaced === null) {
         continue;
       }
       this.#host.logger.info(
@@ -474,7 +475,7 @@ export class OutputTimes {
       // which this function has just written it into and which every session of
       // the file shares. It used to be passed as an argument from here, so only
       // a run started by this line ever had it.
-      this.#host.stopEncodeRun(member, `#${index} really begins ${(trueStart - wasAt).toFixed(3)}s later than the table said`);
+      this.#host.stopRun(misplaced, `#${index} really begins ${(trueStart - wasAt).toFixed(3)}s later than the table said`);
     }
     this.#host.planEncodersSoon();
   }

package/services/encode/decode-cost-fit.js

@@ -334,7 +334,7 @@ export function decodeFamilyOf(source) {
   const codec = typeof source?.codec === "string" ? source.codec.trim().toLowerCase() : "";
   const depth = Number(source?.bitDepth);
   const tenBit = Number.isFinite(depth) && depth >= 10;
-  if (codec === "hevc" || codec === "h265" || codec === "x265") {
+  if (codec === "hevc") {
     return tenBit ? "hevc10" : "hevc";
   }
   // ffmpeg's own names. Only what has a clip set: `msmpeg4v3` (DivX 3) is a

package/services/media/container/AviContainer.js

@@ -9,6 +9,7 @@
 
 import { FFMPEG_STREAM_SEARCH_SECONDS } from "./ffmpeg-stream-search.js";
 import { Container } from "./Container.js";
+import { MPEG4_FOURCCS } from "../tracks/codec-names.js";
 import { VideoTrack } from "../tracks/VideoTrack.js";
 import { AudioTrack } from "../tracks/AudioTrack.js";
 import { ContainerTrack } from "../tracks/ContainerTrack.js";
@@ -22,7 +23,6 @@ import { ac3Frame } from "./ac3-frame.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"]);
 /** FFmpeg's input buffer, filled ahead of what its demuxer parses (`IO_BUFFER_SIZE`, libavformat/aviobuf.c n8.1). */
 const FFMPEG_INPUT_BUFFER_BYTES = 32768;
 /** Picture codecs whose every picture stands alone, so decoding order is showing order. */
@@ -473,7 +473,7 @@ export class AviContainer extends Container {
     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()) && !INTRA_PICTURE_CODECS.has(track.codecId.toUpperCase())) {
+      if (track.type === "video" && !["h264", "hevc"].includes(track.codecId) && !MPEG4_FOURCCS.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.");
@@ -651,7 +651,7 @@ export class AviContainer extends Container {
           if (length) await this.#appendPacket(state.index, state.timings, track, { pts, duration, keyframe: true, ranges: [[start, end - 1]] });
           else if (track.type === "video") state.index.extendLastPresentation(trackId, track.timeBase);
           state.clocks.set(trackId, pts + duration);
-          if (!MPEG4_CODECS.has(track.codecId.toUpperCase()) && !["h264", "hevc"].includes(track.codecId) && !MPEG_AUDIO_CODECS.has(track.codecId) && (track.type === "audio" || length)) state.index.coverThrough(trackId, Math.max(0, pts + duration));
+          if (!MPEG4_FOURCCS.has(track.codecId.toUpperCase()) && !["h264", "hevc"].includes(track.codecId) && !MPEG_AUDIO_CODECS.has(track.codecId) && (track.type === "audio" || length)) state.index.coverThrough(trackId, Math.max(0, pts + duration));
         }
         state.at = next;
         state.index.flushPending();
@@ -687,7 +687,7 @@ export class AviContainer extends Container {
       }
       return;
     }
-    if (track.type !== "video" || !MPEG4_CODECS.has(track.codecId.toUpperCase())) {
+    if (track.type !== "video" || !MPEG4_FOURCCS.has(track.codecId.toUpperCase())) {
       index.append(track.trackNumber, packet);
       return;
     }

package/services/media/playback-declarations.js

@@ -1,33 +1,20 @@
 import { AudioTrack } from "./tracks/AudioTrack.js";
 import { TextSubtitleTrack } from "./tracks/TextSubtitleTrack.js";
 import { ContainerTrack } from "./tracks/ContainerTrack.js";
+import { videoCodecName } from "./tracks/codec-names.js";
 
-const VIDEO_CODECS = new Map([
-  ["V_MPEG4/ISO/AVC", "h264"], ["avc1", "h264"], ["avc3", "h264"],
-  ["V_MPEGH/ISO/HEVC", "hevc"], ["hvc1", "hevc"], ["hev1", "hevc"],
-  ["V_MPEG1", "mpeg1video"], ["V_MPEG2", "mpeg2video"],
-  ["V_MPEG4/ISO/ASP", "mpeg4"], ["V_MPEG4/ISO/SP", "mpeg4"], ["mp4v", "mpeg4"],
-  ["V_VP8", "vp8"], ["V_VP9", "vp9"], ["vp09", "vp9"],
-  ["V_AV1", "av1"], ["av01", "av1"], ["V_MJPEG", "mjpeg"],
-  ["V_FFV1", "ffv1"], ["V_THEORA", "theora"]
-]);
 const SUBTITLE_CODECS = new Map([
   ["S_TEXT/UTF8", "subrip"], ["S_TEXT/ASS", "ass"], ["S_TEXT/SSA", "ssa"],
   ["S_TEXT/WEBVTT", "webvtt"], ["wvtt", "webvtt"], ["tx3g", "mov_text"],
   ["S_HDMV/PGS", "hdmv_pgs_subtitle"], ["S_VOBSUB", "dvd_subtitle"]
 ]);
-const FOURCC_CODECS = new Map([
-  ["mjpg", "mjpeg"], ["jpeg", "mjpeg"], ["xvid", "mpeg4"],
-  ["divx", "mpeg4"], ["dx50", "mpeg4"], ["mpg2", "mpeg2video"]
-]);
-
 function videoCodecOf(track) {
   let id = track.codecId;
   if (id === "V_MS/VFW/FOURCC" && track.codecPrivateB64) {
     const header = Buffer.from(track.codecPrivateB64, "base64");
     if (header.length >= 20) id = header.toString("ascii", 16, 20);
   }
-  return VIDEO_CODECS.get(id) ?? FOURCC_CODECS.get(id.toLowerCase()) ?? id.toLowerCase();
+  return videoCodecName(id);
 }
 
 /** One playback inventory, taken from the same declarations used for input. */

package/services/media/tracks/AudioTrack.js

@@ -11,40 +11,9 @@
  */
 
 import { codecParametersOf, peakKbpsOf } from "./audio-bound.js";
+import { audioCodecName } from "./codec-names.js";
 import { ContainerTrack } from "./ContainerTrack.js";
 
-/**
- * Codec identifiers as containers write them, against the name ffmpeg prints.
- *
- * Needed because the browser decides whether it can play a soundtrack from that
- * name, and for a sidecar file there is no ffmpeg banner to read it from — the
- * track came from the container's own table, where Matroska writes `A_AC3` and
- * MP4 writes `ac-3` for the thing ffmpeg calls `ac3`. Only what a soundtrack can
- * actually be is listed; an identifier not here is reported as it was written,
- * which the browser treats as one it does not know and therefore transcodes.
- */
-const CODEC_NAMES = new Map([
-  ["A_AAC", "aac"],
-  ["A_AC3", "ac3"],
-  ["A_EAC3", "eac3"],
-  ["A_DTS", "dts"],
-  ["A_FLAC", "flac"],
-  ["A_OPUS", "opus"],
-  ["A_VORBIS", "vorbis"],
-  ["A_TRUEHD", "truehd"],
-  ["A_MPEG/L3", "mp3"],
-  ["A_MPEG/L2", "mp2"],
-  ["A_ALAC", "alac"],
-  ["mp4a", "aac"],
-  ["ac-3", "ac3"],
-  ["ec-3", "eac3"],
-  ["alac", "alac"],
-  ["opus", "opus"],
-  ["Opus", "opus"],
-  ["fLaC", "flac"],
-  ["flac", "flac"]
-]);
-
 /**
  * Extensions of raw elementary streams, against the codec they carry.
  *
@@ -126,21 +95,7 @@ export class AudioTrack extends ContainerTrack {
     }
     const codecId = typeof track?.codecId === "string" ? track.codecId.trim() : "";
     if (codecId.length > 0) {
-      const known = CODEC_NAMES.get(codecId);
-      if (known) {
-        return known;
-      }
-      // Matroska allows a suffix — `A_AAC/MPEG4/LC`, `A_PCM/INT/LIT` — so the
-      // family is what the first two segments say.
-      const family = codecId.split("/").slice(0, 2).join("/");
-      const byFamily = CODEC_NAMES.get(family) ?? CODEC_NAMES.get(codecId.split("/")[0]);
-      if (byFamily) {
-        return byFamily;
-      }
-      if (codecId.startsWith("A_PCM")) {
-        return "pcm";
-      }
-      return codecId.toLowerCase();
+      return audioCodecName(codecId);
     }
     return CODEC_BY_EXTENSION.get(extension) ?? "";
   }

package/services/media/tracks/codec-names.js

@@ -0,0 +1,83 @@
+/**
+ * @file The one table that names codecs.
+ *
+ * Containers write a codec as a Matroska id (`V_MPEG4/ISO/AVC`), an MP4 sample
+ * entry (`avc1`) or an AVI FOURCC (`XVID`); the rest of the proxy speaks the
+ * names ffmpeg prints (`h264`, `mpeg4`). Every translation lives here, so a
+ * FOURCC cannot be named one thing for the inventory and another for the
+ * container that reads it (torrent-tv/meta#284). Pure: imports nothing.
+ */
+
+/** FOURCCs that are MPEG-4 Part 2 (ASP/SP) whatever their case. */
+export const MPEG4_FOURCCS = new Set(["FMP4", "XVID", "DIVX", "DX50", "MP4V", "M4S2", "MP4S"]);
+
+const VIDEO_NAMES = new Map([
+  ["V_MPEG4/ISO/AVC", "h264"], ["avc1", "h264"], ["avc3", "h264"],
+  ["V_MPEGH/ISO/HEVC", "hevc"], ["hvc1", "hevc"], ["hev1", "hevc"],
+  ["V_MPEG1", "mpeg1video"], ["V_MPEG2", "mpeg2video"], ["mpg2", "mpeg2video"],
+  ["V_MPEG4/ISO/ASP", "mpeg4"], ["V_MPEG4/ISO/SP", "mpeg4"],
+  ["V_VP8", "vp8"], ["V_VP9", "vp9"], ["vp09", "vp9"],
+  ["V_AV1", "av1"], ["av01", "av1"], ["V_MJPEG", "mjpeg"], ["mjpg", "mjpeg"], ["jpeg", "mjpeg"],
+  ["V_FFV1", "ffv1"], ["V_THEORA", "theora"]
+].map(([id, name]) => [id.toLowerCase(), name]));
+
+/** The ffmpeg name of a video track from its codec id or FOURCC, in any case; unknown ids come back lower-cased. */
+export function videoCodecName(id) {
+  const key = String(id ?? "").toLowerCase();
+  if (MPEG4_FOURCCS.has(key.toUpperCase())) return "mpeg4";
+  return VIDEO_NAMES.get(key) ?? key;
+}
+
+const AUDIO_NAMES = new Map([
+  ["A_AAC", "aac"], ["A_AC3", "ac3"], ["A_EAC3", "eac3"], ["A_DTS", "dts"], ["A_FLAC", "flac"],
+  ["A_OPUS", "opus"], ["A_VORBIS", "vorbis"], ["A_TRUEHD", "truehd"], ["A_MPEG/L3", "mp3"],
+  ["A_MPEG/L2", "mp2"], ["A_ALAC", "alac"],
+  ["mp4a", "aac"], ["ac-3", "ac3"], ["ec-3", "eac3"], ["alac", "alac"],
+  ["opus", "opus"], ["Opus", "opus"], ["fLaC", "flac"], ["flac", "flac"]
+]);
+
+/**
+ * The ffmpeg name of a soundtrack from its container id. Matroska allows a
+ * suffix (`A_AAC/MPEG4/LC`, `A_PCM/INT/LIT`), so the family is what the first
+ * two segments say. An id not listed is reported as written, lower-cased.
+ */
+export function audioCodecName(codecId) {
+  const id = String(codecId ?? "").trim();
+  const known = AUDIO_NAMES.get(id);
+  if (known) return known;
+  const family = id.split("/").slice(0, 2).join("/");
+  const byFamily = AUDIO_NAMES.get(family) ?? AUDIO_NAMES.get(id.split("/")[0]);
+  if (byFamily) return byFamily;
+  if (id.startsWith("A_PCM")) return "pcm";
+  return id.toLowerCase();
+}
+
+const MATROSKA_IDS = new Map([
+  ["h264", "V_MPEG4/ISO/AVC"], ["hevc", "V_MPEGH/ISO/HEVC"], ["av1", "V_AV1"], ["vp9", "V_VP9"],
+  ["vp8", "V_VP8"], ["mjpeg", "V_MJPEG"], ["ffv1", "V_FFV1"], ["theora", "V_THEORA"],
+  ["jpeg2000", "V_JPEG2000"], ["mpeg1video", "V_MPEG1"], ["mpeg2video", "V_MPEG2"], ["mpeg4", "V_MPEG4/ISO/ASP"],
+  ["aac", "A_AAC"], ["mp3", "A_MPEG/L3"], ["mp2", "A_MPEG/L2"], ["mp1", "A_MPEG/L1"],
+  ["ac3", "A_AC3"], ["eac3", "A_EAC3"], ["opus", "A_OPUS"], ["flac", "A_FLAC"], ["dts", "A_DTS"],
+  ["vorbis", "A_VORBIS"], ["alac", "A_ALAC"], ["truehd", "A_TRUEHD"]
+]);
+// Spellings an input may carry besides the canonical name, taken exactly: a
+// codec outside this list has no Matroska declaration, and `M4S2` or `xvid`
+// stay refused because an input's key follows its declared track identity.
+const MATROSKA_SPELLINGS = [
+  ...["avc1", "avc3", "hvc1", "hev1", "av01"].map(spelling => [spelling, videoCodecName(spelling)]),
+  ...["FMP4", "XVID", "DIVX"].map(spelling => [spelling, "mpeg4"]),
+  ...["mp4a", "ac-3", "ec-3", "Opus", "fLaC"].map(spelling => [spelling, audioCodecName(spelling)])
+];
+
+/**
+ * The exact Matroska CodecID a canonical codec name is declared as, or
+ * `undefined` when there is none. Reverse of the names above, never wider.
+ */
+export function matroskaIdOf(codec) {
+  if (/^[VA]_/.test(codec)) return codec;
+  if (/^pcm_[su](?:16|24|32|64)le$/.test(codec) || /^pcm_[su]8(?:le|be)?$/.test(codec)) return "A_PCM/INT/LIT";
+  if (/^pcm_[su](?:16|24|32|64)be$/.test(codec)) return "A_PCM/INT/BIG";
+  if (/^pcm_f(?:32|64)(?:le|be)$/.test(codec)) return "A_PCM/FLOAT/IEEE";
+  const spelled = MATROSKA_SPELLINGS.find(([spelling]) => spelling === codec);
+  return MATROSKA_IDS.get(spelled ? spelled[1] : codec);
+}

package/services/server/wire-outputs.js

@@ -12,6 +12,7 @@ import { EventEmitter } from "node:events";
 import { writeJsonAtomic } from "../../utils/atomic-json.js";
 import { logger } from "../../utils/logger.js";
 import { KeyframeTables } from "../media/KeyframeTables.js";
+import { matroskaIdOf } from "../media/tracks/codec-names.js";
 import { bandOf, WaitLedger } from "../encode/OutputWaitLedger.js";
 import { readEndedChildrenCpuSeconds, readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
@@ -336,7 +337,7 @@ export function wireOutputs({
   parts.outputTimes = new OutputTimes({
     logger,
     runsOf: (...args) => parts.encodeRuns.runsOf(...args),
-    stopEncodeRun: (...args) => parts.encodeRuns.stopEncodeRun(...args),
+    stopRun: (...args) => parts.encodeRuns.stopRun(...args),
     planEncodersSoon: (...args) => parts.encodeRuns.planEncodersSoon(...args),
     get outputs() { return parts.outputs; },
     get segmentDurationSec() { return parts.segmentDurationSec; },
@@ -1197,6 +1198,7 @@ export function wireOutputs({
   parts.encodeInputs = encodeInputs ?? (typeof encodeInputResolution?.resolve === "function" ? new EncodeInputs({
     resolve: (...args) => encodeInputResolution.resolve(...args),
     readRanges: readEncodeRanges,
+    matroskaIdOf,
     openWholeFile: openEncodeWholeFile,
     heldRanges: readEncodeHeldRanges,
     stretchCopied: (...args) => encodeInputResolution.stretchCopied(...args),