nixamp 0.28.34 → 0.28.36

package/dist/audio.d.ts

@@ -137,7 +137,7 @@ export interface Codecs {
  * answering other requests, and a synchronous probe per media request is how
  * the whole library came to be tagged with the process wedged solid.
  */
-export declare function codecsOf(tools: Tools, path: string, input?: string[]): Promise<Codecs>;
+export declare function codecsOf(tools: Tools, path: string, input?: string[], signal?: AbortSignal): Promise<Codecs>;
 /**
  * The title, artist and album a file carries in its tags, however the
  * container spells the keys (ID3 says TIT2 but ffprobe says title; MP4 and

package/dist/audio.js

@@ -356,7 +356,7 @@ function readTags(stdout, fallback) {
  * answering other requests, and a synchronous probe per media request is how
  * the whole library came to be tagged with the process wedged solid.
  */
-export async function codecsOf(tools, path, input = []) {
+export async function codecsOf(tools, path, input = [], signal) {
     const [cmd, ...rest] = tools.ffprobe;
     const empty = { video: "", audio: "", container: "" };
     if (!cmd)
@@ -380,7 +380,7 @@ export async function codecsOf(tools, path, input = []) {
             // Headers the source's site expects, for a link resolved by yt-dlp.
             ...input,
             path,
-        ], { stdio: ["ignore", "pipe", "ignore"] });
+        ], { stdio: ["ignore", "pipe", "ignore"], signal });
         let out = "";
         child.stdout.on("data", (chunk) => {
             out += chunk.toString("utf8");

package/dist/channels.d.ts

@@ -35,9 +35,9 @@ export interface ChannelInfo {
     redials?: number;
     /**
      * For a channel that plays a list: the entries, in order, and which one is
-     * on. When one ends the next is dialled at once, and the last is followed
-     * by the first: a station, not a file. A restart picks up at the entry
-     * that was on.
+     * on. Local files are normalized into one continuous stream. After the
+     * final entry the show ends. A restart picks up at the saved entry and
+     * position within it.
      */
     playlist?: string[];
     playlistAt?: number;
@@ -104,6 +104,7 @@ export interface PullResume {
     position: number;
     /** For a list of things rather than one: every entry, in order. */
     playlist?: string[];
+    playlistAt?: number;
 }
 /**
  * A source read by us rather than by ffmpeg: what to tell ffmpeg it is,
@@ -159,18 +160,9 @@ export declare const BACKLOG_AUDIO: number;
  * until the channel ended, however long that was.
  */
 export declare const LISTENER_QUEUE: number;
-/**
- * The backlog is really a number of seconds, and four megabytes was that
- * number for the stream we happened to have.
- *
- * Six seconds of 720p is about 4 MB. Six seconds of a 1080p transport stream
- * copied straight through is nearer 12, and of 4K nearer 30 -- so a fixed
- * 4 MB hands a 4K joiner under a second of video, which is the live edge with
- * no cushion, which is the play-wait-play loop the backlog exists to prevent.
- * So the cap follows the stream: seconds times the rate it is actually
- * running at, between the old floor and a ceiling that keeps a channel's
- * memory bounded whatever it is carrying.
- */
+/** Media-time window for complete MP4 fragments. Byte limits are a separate
+ * memory ceiling; the measured byte rate is only a fallback for inputs with
+ * no usable fragment timestamps. It must never make low-bitrate video old. */
 export declare const BACKLOG_SECONDS = 6;
 export declare const BACKLOG_VIDEO_MAX: number;
 /**
@@ -187,6 +179,7 @@ export declare const RATE_WINDOW_MS = 5000;
 export declare function cleanId(value: unknown, fallback?: string): string;
 export interface ChannelOptions {
     ffmpeg: string[];
+    ffprobe?: string[];
     onStart?: (info: ChannelInfo) => void;
     onEnd?: (info: ChannelInfo) => void;
     /**
@@ -250,6 +243,8 @@ export declare class Channel {
      * can begin at; for MP3 any point will do, a frame announces itself.
      */
     private recent;
+    private fragmentClock;
+    private fragmentTimes;
     private recentBytes;
     /** The rate window: when it opened, what has arrived in it, and what the last closed one measured. */
     private rateStart;
@@ -266,8 +261,6 @@ export declare class Channel {
     private readonly sourceTaps;
     /** Pulls the plug on the current read-through, when there is one. */
     private throughAbort;
-    /** ffmpeg concat manifest for a local multi-file live. */
-    private concatListPath;
     constructor(info: ChannelInfo, options: ChannelOptions, onGone: (id: string) => void);
     start(format: string): void;
     /**

package/dist/channels.js

@@ -16,10 +16,10 @@
  */
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { tmpdir } from "node:os";
-import { Fragments, isOpening } from "./fragments.js";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { PlaylistInputStream } from "./playlist-input.js";
+import { FragmentClock, Fragments, isOpening } from "./fragments.js";
 /**
  * How far back of the saved place a film is picked up from, in seconds. The
  * place is written down every so often and a restart lands between two
@@ -65,18 +65,9 @@ export const BACKLOG_AUDIO = 64 * 1024;
  * until the channel ended, however long that was.
  */
 export const LISTENER_QUEUE = 16 * 1024 * 1024;
-/**
- * The backlog is really a number of seconds, and four megabytes was that
- * number for the stream we happened to have.
- *
- * Six seconds of 720p is about 4 MB. Six seconds of a 1080p transport stream
- * copied straight through is nearer 12, and of 4K nearer 30 -- so a fixed
- * 4 MB hands a 4K joiner under a second of video, which is the live edge with
- * no cushion, which is the play-wait-play loop the backlog exists to prevent.
- * So the cap follows the stream: seconds times the rate it is actually
- * running at, between the old floor and a ceiling that keeps a channel's
- * memory bounded whatever it is carrying.
- */
+/** Media-time window for complete MP4 fragments. Byte limits are a separate
+ * memory ceiling; the measured byte rate is only a fallback for inputs with
+ * no usable fragment timestamps. It must never make low-bitrate video old. */
 export const BACKLOG_SECONDS = 6;
 export const BACKLOG_VIDEO_MAX = 48 * 1024 * 1024;
 /**
@@ -166,6 +157,8 @@ export class Channel {
      * can begin at; for MP3 any point will do, a frame announces itself.
      */
     recent = [];
+    fragmentClock = new FragmentClock();
+    fragmentTimes = new WeakMap();
     recentBytes = 0;
     /** The rate window: when it opened, what has arrived in it, and what the last closed one measured. */
     rateStart = 0;
@@ -182,8 +175,6 @@ export class Channel {
     sourceTaps = new Set();
     /** Pulls the plug on the current read-through, when there is one. */
     throughAbort = null;
-    /** ffmpeg concat manifest for a local multi-file live. */
-    concatListPath = null;
     constructor(info, options, onGone) {
         this.info = info;
         this.options = options;
@@ -240,44 +231,29 @@ export class Channel {
             this.fragments = new Fragments();
         const [command, ...prefix] = this.options.ffmpeg;
         this.info.live = resume.live;
-        if (!resume.live)
+        if (!resume.live || resume.playlist?.length)
             this.info.position = Math.max(0, resume.position);
         // A list plays entry by entry: the one that is on is what gets dialled,
         // and an entry that ended is followed by the next, at once.
         const list = resume.playlist && resume.playlist.length > 0 ? resume.playlist : null;
-        // A local directory live must be one ffmpeg input. Starting a new ffmpeg
-        // process for every file makes browsers see a new MP4 stream at each
-        // boundary, even when the HTTP listener stays attached. The concat
-        // demuxer keeps timestamps and the output pipe continuous.
-        const concatList = list && list.length > 1 && list.every((one) => !/^https?:\/\//i.test(one))
-            ? list
-            : null;
-        if (this.concatListPath) {
-            rmSync(this.concatListPath, { force: true });
-            this.concatListPath = null;
-        }
-        if (concatList) {
-            const dir = mkdtempSync(join(tmpdir(), "nixamp-playlist-"));
-            this.concatListPath = join(dir, "playlist.txt");
-            const quote = (one) => one.replaceAll("'", "'\\''");
-            writeFileSync(this.concatListPath, concatList.map((one) => `file '${quote(one)}'`).join("\n") + "\n");
-        }
+        const localPlaylist = list && list.length > 1 && list.every(one => !/^https?:\/\//i.test(one)) ? list : null;
         let at = 0;
         if (list) {
             this.info.playlist = list;
-            at = Math.min(Math.max(0, this.info.playlistAt ?? 0), list.length - 1);
+            at = Math.min(Math.max(0, resume.playlistAt ?? this.info.playlistAt ?? 0), list.length - 1);
             this.info.playlistAt = at;
         }
         let current = list ? list[at] : source;
         // The last entry is the end of the show, not a way back to the first:
         // a list that played through is over, and says so with the outro.
-        this.advance = list && list.length > 1 && !concatList
+        this.advance = list && list.length > 1 && !localPlaylist
             ? () => {
                 if (at + 1 >= list.length)
                     return false;
                 at += 1;
                 this.info.playlistAt = at;
                 current = list[at];
+                this.info.position = 0;
                 return true;
             }
             : null;
@@ -296,7 +272,7 @@ export class Channel {
             // the place was written down a moment ago and a moment of it twice is
             // better than a moment of it missing. A live source is joined as is,
             // and a film that has barely started is started.
-            const from = resume.live ? 0 : Math.max(0, Math.floor((this.info.position ?? 0) - REWIND));
+            const from = resume.live && !list ? 0 : Math.max(0, Math.floor((this.info.position ?? 0) - REWIND));
             const seek = from > 0 ? ["-ss", String(from)] : [];
             // Read the source here rather than in ffmpeg, when a policy wants the
             // original bytes and the source is the kind that can be. ffmpeg then
@@ -306,14 +282,19 @@ export class Channel {
             this.throughAbort?.abort();
             this.throughAbort = null;
             // The outro is a file read by ffmpeg itself: a pipe cannot loop.
-            const through = this.outroOn ? null : this.options.through?.(this.info, from, input, audio) ?? null;
-            this.info.teed = through !== null;
-            const concatInput = this.concatListPath
-                ? [
-                    ...(paced ? ["-re"] : []),
-                    "-f", "concat", "-safe", "0", "-i", this.concatListPath,
-                ]
-                : null;
+            const playlistInput = localPlaylist ? new PlaylistInputStream({
+                ffmpeg: this.options.ffmpeg,
+                ffprobe: this.options.ffprobe ?? this.options.ffmpeg.map(one => one.replace(/ffmpeg(?=(?:\.exe)?$)/, "ffprobe")),
+                files: localPlaylist, at: this.info.playlistAt ?? 0, position: from,
+                video: this.info.kind === "video", width: this.info.codecs?.width, height: this.info.codecs?.height,
+            }) : null;
+            const through = this.outroOn ? null : playlistInput
+                ? { format: "mpegts", open: async (signal) => playlistInput.open(signal) }
+                : this.options.through?.(this.info, from, input, audio) ?? null;
+            this.info.teed = through !== null && !playlistInput;
+            const playlistEncode = !playlistInput ? null : this.info.kind === "video"
+                ? ["-c", "copy", "-bsf:a", "aac_adtstoasc", "-f", "mp4", "-movflags", "frag_keyframe+empty_moov+default_base_moof"]
+                : ["-af", "aresample=async=1:first_pts=0", ...encode];
             const child = spawn(command, [
                 ...prefix,
                 "-hide_banner",
@@ -333,7 +314,7 @@ export class Channel {
                         // headers, which only a source read through us leaves out,
                         // are no use to a pipe and are not here (a source that needs
                         // them is not read through us in the first place).
-                        ...input,
+                        ...(playlistInput ? ["-probesize", "32768", "-analyzeduration", "1000000"] : input),
                         "-f", through.format,
                         ...(paced ? ["-re"] : []),
                         "-i", "pipe:0",
@@ -354,12 +335,12 @@ export class Channel {
                         // What the source's site expects on the request: a user agent, a
                         // referer, a cookie. A link resolved by yt-dlp comes with these,
                         // and a CDN that got them from yt-dlp and not from us answers 403.
-                        ...(concatInput ?? [...input, ...seek, "-i", current]),
+                        ...input, ...seek, "-i", current,
                         // The sound, when the site keeps it apart from the picture: a
                         // second input, dialled the same way, that the encode maps in.
                         ...(audio ? [...remoteArgs, ...(paced ? ["-re"] : []), ...input, ...seek, "-i", audio] : []),
                     ]),
-                ...encode,
+                ...(playlistEncode ?? encode),
                 "pipe:1",
             ], { stdio: [through ? "pipe" : "ignore", "pipe", "pipe", "pipe"] });
             let sent = false;
@@ -374,14 +355,22 @@ export class Channel {
             let progress = "";
             child.stdio[3]?.on("data", (chunk) => {
                 progress = (progress + chunk.toString("utf8")).slice(-4000);
-                if (this.child !== child || resume.live)
+                if (this.child !== child || (resume.live && !list))
                     return;
                 const lines = progress.split("\n");
                 progress = lines.pop() ?? "";
                 for (const line of lines) {
                     const match = /^out_time_us=(\d+)/.exec(line.trim());
-                    if (match)
-                        this.info.position = from + Number(match[1]) / 1e6;
+                    if (match) {
+                        const seconds = Number(match[1]) / 1e6;
+                        if (playlistInput) {
+                            const place = playlistInput.place(seconds);
+                            this.info.playlistAt = place.at;
+                            this.info.position = place.position;
+                        }
+                        else
+                            this.info.position = from + seconds;
+                    }
                 }
             });
             child.stdio[3]?.on("error", () => undefined);
@@ -389,6 +378,8 @@ export class Channel {
                 // An ffmpeg that was replaced can still have a chunk in the pipe.
                 if (this.child !== child)
                     return;
+                if (!sent)
+                    this.info.error = undefined;
                 sent = true;
                 this.info.bytes += chunk.byteLength;
                 this.rearm(child);
@@ -399,9 +390,14 @@ export class Channel {
             // Only the ffmpeg we are currently running gets to say the source
             // dropped. One that was killed to make way for a restart is not news.
             child.on("error", () => { if (this.child === child)
-                this.dropped(sent); });
-            child.on("close", () => { if (this.child === child)
-                this.dropped(sent); });
+                this.dropped(sent, false); });
+            child.on("close", (code, signal) => {
+                if (this.child !== child)
+                    return;
+                if (playlistInput?.error)
+                    this.stderr = playlistInput.error.message;
+                this.dropped(sent, code === 0 && !signal && (!playlistInput || playlistInput.complete));
+            });
         };
         this.redial = dial;
         dial();
@@ -423,6 +419,7 @@ export class Channel {
         const kind = this.info.kind ?? "audio";
         const old = this.child;
         this.child = null;
+        this.throughAbort?.abort();
         if (this.watchdog)
             clearTimeout(this.watchdog);
         this.watchdog = null;
@@ -473,7 +470,7 @@ export class Channel {
             this.info.playlistAt = 0;
             this.startOver();
             const show = this.dialed;
-            this.pull(show.source, show.encode, show.paced, show.stall, show.input, show.audio, { ...show.resume, position: 0 });
+            this.pull(show.source, show.encode, show.paced, show.stall, show.input, show.audio, { ...show.resume, position: 0, playlistAt: 0 });
             return true;
         }
         const dial = this.redial;
@@ -510,6 +507,8 @@ export class Channel {
         if (this.info.kind === "video")
             this.fragments = new Fragments();
         this.recent = [];
+        this.fragmentClock = new FragmentClock();
+        this.fragmentTimes = new WeakMap();
         this.recentBytes = 0;
         // A new source may be a different size of stream, and the rate measured
         // off the old one is not evidence about this one.
@@ -569,7 +568,7 @@ export class Channel {
      * worth dialling again, and a URL that has never once produced a byte is a
      * mistake somebody made, and retrying it for ever helps nobody.
      */
-    dropped(sent) {
+    dropped(sent, clean = false) {
         if (this.closing || !this.redial)
             return;
         // An outro that stopped is over; there is nothing after it.
@@ -578,28 +577,28 @@ export class Channel {
             return;
         }
         this.child = null;
+        this.throughAbort?.abort();
         if (this.watchdog)
             clearTimeout(this.watchdog);
         this.watchdog = null;
         const said = lastLine(this.stderr);
         if (said)
             this.info.error = said;
-        this.failures = sent ? 0 : this.failures + 1;
+        this.failures = sent && clean ? 0 : this.failures + 1;
         if (this.failures >= GIVE_UP) {
             this.close();
             return;
         }
-        // A list moves on. An entry that played to its end is not a source that
-        // dropped: the next is dialled now, and it is not a redial. One that
-        // gave nothing is skipped the same way, counted as the failure it was,
-        // so a list of dead links gives up rather than cycling for ever.
-        const moved = this.advance?.() ?? false;
+        // Only a clean EOF advances a per-URL playlist. Decoder errors, a
+        // watchdog kill, or a failed normalized input recover at the saved place
+        // with bounded retries; an MP4 header alone is not a completed show.
+        const moved = clean ? this.advance?.() ?? false : false;
         // A show that ended: a film or a podcast that played to its end, a
         // list whose last entry did. That is not a source that dropped, and it
         // is not dialled again from the top; it is over, and the outro says
         // so. A live feed that stopped is a feed that dropped, and is redialled.
         const list = (this.info.playlist?.length ?? 0) > 0;
-        if (sent && !moved && (this.info.live === false || list)) {
+        if (clean && sent && !moved && (this.info.live === false || list)) {
             void this.endShow();
             return;
         }
@@ -637,8 +636,23 @@ export class Channel {
         }
         const cap = this.backlogCap();
         for (const box of this.fragments.push(chunk)) {
+            const time = this.fragmentClock.read(box);
+            if (time !== null)
+                this.fragmentTimes.set(box, time);
             if (!isOpening(boxType(box)))
-                this.remember(box, cap, true);
+                this.remember(box, time === null ? cap : BACKLOG_VIDEO_MAX, true);
+            if (time !== null) {
+                // Drop complete old fragments even when six seconds occupy only a
+                // few kilobytes (slides, static cameras, or a paused game screen).
+                while (this.recent.length > 0) {
+                    const oldest = this.fragmentTimes.get(this.recent[0]);
+                    if (oldest === undefined || time - oldest < BACKLOG_SECONDS)
+                        break;
+                    do {
+                        this.recentBytes -= this.recent.shift().byteLength;
+                    } while (this.recent.length && boxType(this.recent[0]) !== "moof");
+                }
+            }
             this.send(box);
         }
     }
@@ -818,8 +832,13 @@ export class Channel {
                     // Wait for ffmpeg to take it, or for the pipe to go: a pipe that
                     // closed never drains, and waiting on it would hold the read open.
                     await new Promise((done) => {
-                        stdin.once("drain", done);
-                        stdin.once("close", done);
+                        const finish = () => {
+                            stdin.off("drain", finish);
+                            stdin.off("close", finish);
+                            done();
+                        };
+                        stdin.once("drain", finish);
+                        stdin.once("close", finish);
                     });
                 }
             }
@@ -917,10 +936,6 @@ export class Channel {
         this.child = null;
         this.throughAbort?.abort();
         this.throughAbort = null;
-        if (this.concatListPath) {
-            rmSync(dirname(this.concatListPath), { force: true, recursive: true });
-            this.concatListPath = null;
-        }
         this.endTaps();
         try {
             child?.stdin?.end();
@@ -1228,7 +1243,7 @@ export function rememberedNow(channels) {
             kept.codecs = one.codecs;
         if (typeof one.live === "boolean")
             kept.live = one.live;
-        if (!one.live && typeof one.position === "number" && one.position > 0)
+        if ((!one.live || one.playlist?.length) && typeof one.position === "number" && one.position > 0)
             kept.position = Math.floor(one.position);
         if (one.startedBy)
             kept.startedBy = one.startedBy;

package/dist/fragments.d.ts

@@ -35,6 +35,11 @@ export declare function firstBox(buffer: Buffer): {
 } | null;
 /** The boxes that describe the stream rather than carry it. */
 export declare function isOpening(type: string): boolean;
+/** Decode timestamps use each track's own timescale, never its byte rate. */
+export declare class FragmentClock {
+    private scales;
+    read(box: Buffer): number | null;
+}
 /**
  * A fragmented MP4 arriving in pieces, handed back a box at a time.
  *

package/dist/fragments.js

@@ -60,6 +60,57 @@ export function firstBox(buffer) {
 export function isOpening(type) {
     return type === "ftyp" || type === "moov";
 }
+function children(box) {
+    let rest = box.subarray(box.readUInt32BE(0) === 1 ? BIG : HEADER);
+    const found = [];
+    for (;;) {
+        const next = firstBox(rest);
+        if (!next)
+            return found;
+        found.push(next.box);
+        rest = next.rest;
+    }
+}
+/** Decode timestamps use each track's own timescale, never its byte rate. */
+export class FragmentClock {
+    scales = new Map();
+    read(box) {
+        const type = box.toString("latin1", 4, 8);
+        if (type === "moov") {
+            for (const track of children(box).filter(one => one.type === "trak")) {
+                const parts = children(track.bytes);
+                const tkhd = parts.find(one => one.type === "tkhd")?.bytes;
+                const mdia = parts.find(one => one.type === "mdia")?.bytes;
+                const mdhd = mdia && children(mdia).find(one => one.type === "mdhd")?.bytes;
+                if (!tkhd || !mdhd)
+                    continue;
+                const idAt = tkhd[8] === 1 ? 28 : 20;
+                const scaleAt = mdhd[8] === 1 ? 28 : 20;
+                if (tkhd.length < idAt + 4 || mdhd.length < scaleAt + 4)
+                    continue;
+                const scale = mdhd.readUInt32BE(scaleAt);
+                if (scale)
+                    this.scales.set(tkhd.readUInt32BE(idAt), scale);
+            }
+        }
+        if (type !== "moof")
+            return null;
+        const times = [];
+        for (const track of children(box).filter(one => one.type === "traf")) {
+            const parts = children(track.bytes);
+            const tfhd = parts.find(one => one.type === "tfhd")?.bytes;
+            const tfdt = parts.find(one => one.type === "tfdt")?.bytes;
+            if (!tfhd || tfhd.length < 16 || !tfdt || tfdt.length < (tfdt[8] === 1 ? 20 : 16))
+                continue;
+            const scale = this.scales.get(tfhd.readUInt32BE(12));
+            if (!scale)
+                continue;
+            const time = tfdt[8] === 1 ? Number(tfdt.readBigUInt64BE(12)) : tfdt.readUInt32BE(12);
+            times.push(time / scale);
+        }
+        return times.length ? Math.min(...times) : null;
+    }
+}
 /**
  * A fragmented MP4 arriving in pieces, handed back a box at a time.
  *

package/dist/playlist-input.d.ts

@@ -0,0 +1,26 @@
+export interface PlaylistInput {
+    ffmpeg: string[];
+    ffprobe: string[];
+    files: string[];
+    at: number;
+    position: number;
+    video: boolean;
+    width?: number;
+    height?: number;
+}
+/** Decode each file independently; feed one persistent muxer a fixed stream
+ * profile and continuous timestamps. A concat demuxer cannot decode a list
+ * whose input codecs differ. Only one entry is encoded at a time, with pipe
+ * backpressure bounding read-ahead independently of the directory's size. */
+export declare class PlaylistInputStream {
+    private readonly options;
+    private entries;
+    error: Error | null;
+    complete: boolean;
+    constructor(options: PlaylistInput);
+    place(seconds: number): {
+        at: number;
+        position: number;
+    };
+    open(signal: AbortSignal): AsyncGenerator<Buffer>;
+}

package/dist/playlist-input.js

@@ -0,0 +1,95 @@
+import { spawn } from "node:child_process";
+import { codecsOf } from "./audio.js";
+/** Decode each file independently; feed one persistent muxer a fixed stream
+ * profile and continuous timestamps. A concat demuxer cannot decode a list
+ * whose input codecs differ. Only one entry is encoded at a time, with pipe
+ * backpressure bounding read-ahead independently of the directory's size. */
+export class PlaylistInputStream {
+    options;
+    entries = [];
+    error = null;
+    complete = false;
+    constructor(options) {
+        this.options = options;
+    }
+    place(seconds) {
+        const entry = this.entries.findLast(one => seconds >= one.start) ?? this.entries[0];
+        return entry ? { at: entry.at, position: Math.max(0, seconds - entry.start + entry.position) }
+            : { at: this.options.at, position: this.options.position };
+    }
+    async *open(signal) {
+        const o = this.options;
+        const [command, ...prefix] = o.ffmpeg;
+        const ratio = Math.min(1, 1280 / (o.width || 1280), 720 / (o.height || 720));
+        const width = Math.max(2, Math.floor((o.width || 1280) * ratio / 2) * 2);
+        const height = Math.max(2, Math.floor((o.height || 720) * ratio / 2) * 2);
+        let offset = 0;
+        try {
+            for (let at = o.at; at < o.files.length && !signal.aborted; at++) {
+                const file = o.files[at];
+                const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
+                if (signal.aborted)
+                    return;
+                if (!codecs.audio && !codecs.video)
+                    throw new Error(`Cannot decode playlist entry ${at + 1}`);
+                const position = at === o.at ? o.position : 0;
+                const duration = (codecs.duration ?? 0) - position;
+                if (duration <= 0)
+                    throw new Error(`No playable duration for playlist entry ${at + 1}`);
+                this.entries.push({ at, start: offset, position });
+                const hasVideo = Boolean(codecs.video);
+                const extra = o.video && !hasVideo
+                    ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
+                    : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
+                const args = [
+                    ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
+                    "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), "-i", file,
+                    ...extra, "-t", String(duration),
+                    ...(o.video ? [
+                        "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
+                        "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
+                        "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
+                        "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
+                    ] : ["-map", "0:a:0", "-vn"]),
+                    "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
+                    "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
+                    "-f", "mpegts", "pipe:1",
+                ];
+                const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+                let tail = "";
+                child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
+                const closed = new Promise((resolve) => {
+                    child.once("error", error => { tail = error.message; resolve(-1); });
+                    child.once("close", code => resolve(code));
+                });
+                const abort = () => { child.kill("SIGKILL"); };
+                signal.addEventListener("abort", abort, { once: true });
+                try {
+                    for await (const chunk of child.stdout) {
+                        if (signal.aborted)
+                            return;
+                        yield chunk;
+                    }
+                    const code = await closed;
+                    if (signal.aborted)
+                        return;
+                    if (code !== 0)
+                        throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
+                }
+                finally {
+                    signal.removeEventListener("abort", abort);
+                    abort();
+                    await closed;
+                }
+                // Match the frame grid used above so rounding cannot accumulate a
+                // backwards timestamp over hundreds of short files.
+                offset += o.video ? Math.ceil(duration * 30) / 30 : duration;
+            }
+            this.complete = !signal.aborted;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error : new Error(String(error));
+            throw this.error;
+        }
+    }
+}