nixamp 0.28.45 → 0.30.1

package/dist/playlist-input.js

@@ -1,5 +1,12 @@
 import { spawn } from "node:child_process";
+import { protocolArgs } from "./decoder-policy.js";
 import { codecsOf } from "./audio.js";
+/**
+ * How many entries in a row may fail before the list is given up on. A
+ * corrupt file is skipped; a list where nothing plays is an error, said once,
+ * not a loop.
+ */
+export const MAX_FAILURES_IN_A_ROW = 5;
 /** 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
@@ -12,11 +19,26 @@ export class PlaylistInputStream {
     constructor(options) {
         this.options = options;
     }
+    /** Every entry that has started, in the order it started, with where it sits in the stream. */
+    get history() {
+        return this.entries;
+    }
     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 };
     }
+    /** The decoder for the entry that is on, so skip() can end it early. */
+    stopCurrent = null;
+    skipping = false;
+    /** End the entry that is on and go to the next. False when nothing is on. */
+    skip() {
+        if (!this.stopCurrent)
+            return false;
+        this.skipping = true;
+        this.stopCurrent();
+        return true;
+    }
     async *open(signal) {
         const o = this.options;
         const [command, ...prefix] = o.ffmpeg;
@@ -24,66 +46,148 @@ export class PlaylistInputStream {
         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;
+        let failuresInARow = 0;
+        let first = true;
         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)]));
+            const orderFor = (list) => o.order ? o.order(list.length).filter((one) => one >= 0 && one < list.length) : list.map((_, index) => index);
+            let files = o.current?.() ?? o.files;
+            if (files.length === 0)
+                throw new Error("The playlist is empty");
+            let order = orderFor(files);
+            let step = Math.min(o.at, order.length);
+            let played = 0;
+            let last = "";
+            for (;;) {
                 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) {
+                    break;
+                // Asked at every boundary, so an edit lands on the next track. The
+                // list goes on after the file that just played, where the new list
+                // has it; a shuffled list draws a new order.
+                if (o.current) {
+                    const fresh = o.current();
+                    if (fresh.length !== files.length || fresh.some((one, index) => one !== files[index])) {
+                        if (fresh.length === 0)
+                            throw new Error("The playlist is empty");
+                        files = fresh;
+                        order = orderFor(files);
+                        const where = last ? files.indexOf(last) : -1;
+                        step = o.order ? 0 : where >= 0 ? where + 1 : Math.min(step, files.length);
+                    }
+                }
+                if (step >= order.length) {
+                    if (!o.repeat)
+                        break;
+                    // A pass where everything was passed over is a list with nothing
+                    // to play, and repeating it would be the loop this exists to avoid.
+                    if (played === 0)
+                        throw new Error("Nothing in this playlist would play");
+                    played = 0;
+                    order = orderFor(files);
+                    step = 0;
+                    continue;
+                }
+                {
+                    const at = order[step];
+                    step += 1;
+                    const file = files[at];
+                    last = file;
+                    if (o.excluded?.(file))
+                        continue;
+                    const position = first && step - 1 === o.at ? o.position : 0;
+                    first = false;
+                    let reached = 0;
+                    try {
+                        const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
                         if (signal.aborted)
                             return;
-                        yield chunk;
+                        if (!codecs.audio && !codecs.video)
+                            throw new Error(`Cannot decode playlist entry ${at + 1}`);
+                        const duration = (codecs.duration ?? 0) - position;
+                        if (duration <= 0)
+                            throw new Error(`No playable duration for playlist entry ${at + 1}`);
+                        this.entries.push({ at, file, 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",
+                            // How far this entry got, so an entry cut short -- skipped, or
+                            // broken halfway -- moves the clock by what was played and the
+                            // next one starts where this one stopped, not after a gap.
+                            "-progress", "pipe:3", "-stats_period", "0.5",
+                            "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), ...protocolArgs(file), "-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", "pipe"] });
+                        let tail = "";
+                        child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
+                        child.stdio[3]?.on("data", (chunk) => {
+                            const found = /out_time_us=(\d+)/g;
+                            let match;
+                            while ((match = found.exec(chunk.toString())) !== null)
+                                reached = Math.max(reached, Number(match[1]) / 1e6);
+                        });
+                        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 });
+                        this.stopCurrent = abort;
+                        let skipped = false;
+                        try {
+                            for await (const chunk of child.stdout) {
+                                if (signal.aborted)
+                                    return;
+                                yield chunk;
+                            }
+                            const code = await closed;
+                            if (signal.aborted)
+                                return;
+                            skipped = this.skipping;
+                            if (code !== 0 && !skipped)
+                                throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
+                        }
+                        finally {
+                            this.stopCurrent = null;
+                            this.skipping = false;
+                            signal.removeEventListener("abort", abort);
+                            abort();
+                            await closed;
+                        }
+                        failuresInARow = 0;
+                        played += 1;
+                        // Match the frame grid used above so rounding cannot accumulate a
+                        // backwards timestamp over hundreds of short files.
+                        const length = skipped ? Math.min(duration, reached) : duration;
+                        offset += o.video ? Math.ceil(length * 30) / 30 : length;
+                    }
+                    catch (error) {
+                        if (signal.aborted || !o.passOver)
+                            throw error;
+                        // Passed over, not dialled again: the next entry is what a
+                        // listener should hear, and a file that will not decode now will
+                        // not decode in two seconds either.
+                        const reason = error instanceof Error ? error.message : String(error);
+                        o.onFailure?.({ at, file, reason });
+                        if (reached > 0)
+                            offset += o.video ? Math.ceil(reached * 30) / 30 : reached;
+                        failuresInARow += 1;
+                        if (failuresInARow >= Math.min(MAX_FAILURES_IN_A_ROW, Math.max(1, files.length))) {
+                            throw new Error(`Nothing in this playlist would play: ${reason}`);
+                        }
                     }
-                    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;
         }

package/dist/publish-choice.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Whether this server goes in the public directory.
+ *
+ * A listing is a phone code and a link anybody can open, so it is a thing
+ * somebody chose, not a thing that happens because a daemon had no terminal
+ * to ask on. The choice is asked once, or taken from a flag, and written into
+ * config.json beside the library, and every later start reads it back.
+ *
+ * Servers that were listed before the choice was written down keep being
+ * listed: a daemon without a terminal used to publish by itself, and quietly
+ * taking it off the directory on an update would be changing somebody's
+ * choice for them. A server new to this machine is not listed until asked.
+ */
+export type PublishFlag = "ask" | "yes" | "no";
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export declare function publishChoice(flag: PublishFlag, recorded: boolean | undefined, interactive: boolean, established: boolean): "yes" | "no" | "ask";
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export declare function shouldRecord(flag: PublishFlag, recorded: boolean | undefined): boolean;

package/dist/publish-choice.js

@@ -0,0 +1,17 @@
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export function publishChoice(flag, recorded, interactive, established) {
+    if (flag !== "ask")
+        return flag;
+    if (recorded !== undefined)
+        return recorded ? "yes" : "no";
+    if (interactive)
+        return "ask";
+    return established ? "yes" : "no";
+}
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export function shouldRecord(flag, recorded) {
+    return flag === "ask" && recorded === undefined;
+}

package/dist/server.d.ts

@@ -5,7 +5,7 @@ import { LiveVoice } from "./live-voice.ts";
 import { Connections } from "./connections.ts";
 import { Broadcaster, type Destination, type EncoderSettings } from "./broadcast.ts";
 import { Ingest } from "./ingest.ts";
-import { Channels, type Channel, type ChannelInfo, type RememberedChannel } from "./channels.ts";
+import { Channels, type Channel, type ChannelInfo, type PullResume, type RememberedChannel } from "./channels.ts";
 import { Accounts } from "./accounts.ts";
 import { type ResetMail } from "./password-reset.ts";
 import { Handles } from "./handles.ts";
@@ -21,6 +21,8 @@ import { Directory, type LineupEntry } from "./directory.ts";
 import { ArtCache } from "./art.ts";
 import { PartyLine } from "./partyline.ts";
 import { HlsPackagers } from "./hls.ts";
+import { StationRunner } from "./station-runner.ts";
+import { StationStore } from "./stations.ts";
 import { CompressionService } from "./compression/service.ts";
 import { Enricher } from "./enrich.ts";
 import { Follows } from "./follows.ts";
@@ -438,7 +440,26 @@ export interface KnownSource {
     /** A picture and a line about it, from the site or the list that named it. */
     art?: string;
     about?: string;
+    /** A station's rotation (see PullResume.rotation). */
+    rotation?: PullResume["rotation"];
+    /** kbps for an audio rendition; 192 when unset. */
+    audioBitrate?: number;
 }
+/**
+ * A station's files, chosen by track index (as /api/folders/live takes them)
+ * or by a folder under the library; null when neither was given. Only files
+ * on this machine and inside the library: a station never reaches past it.
+ */
+export declare function selectStationFiles(engine: Engine, body: {
+    items?: unknown;
+    folder?: unknown;
+}): string[] | null;
+/** What the library knows about one file: its tags, for a now-playing line. */
+export declare function trackFor(engine: Engine, file: string): {
+    title: string;
+    artist: string;
+    album: string;
+} | null;
 /** How many times a source that answers nothing is asked, and how far apart. */
 export declare const PROBE_TRIES = 3;
 export declare const PROBE_RETRY_MS = 1500;
@@ -545,6 +566,11 @@ export declare function joinSubject(url: URL, options: Pick<HandlerOptions, "dir
 /** The shell, titled for what a join link opens, with its picture on the card. */
 export declare function joinDocument(shell: string, subject: JoinSubject, site: string): string;
 export interface HandlerOptions {
+    /** This server's stations and what keeps them on the air. */
+    stations?: {
+        store: StationStore;
+        runner: StationRunner;
+    };
     web: string | null;
     /** Branded clients on this same backend, keyed by an explicitly configured host. */
     webSites?: ReadonlyMap<string, import("./web-sites.ts").WebSite>;