nixamp 0.28.45 → 0.30.1

package/src/links.ts

@@ -156,6 +156,11 @@ export function playlistFrom(text: string, base: string): { hls: boolean; source
   return { hls: false, sources: entries.map((entry) => entry.source), image };
 }
 
+/** Asked of every address before it is fetched: "" to go ahead, else why not. */
+export type Guard = (url: string) => Promise<string>;
+
+const PLAYLIST_MAX_REDIRECTS = 5;
+
 /**
  * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
  * here rather than by yt-dlp, which would take the first entry and stop, or
@@ -163,14 +168,28 @@ export function playlistFrom(text: string, base: string): { hls: boolean; source
  */
 export async function resolvePlaylist(
   url: string,
-  options: { timeoutMs?: number; fetcher?: typeof fetch } = {},
+  options: { timeoutMs?: number; fetcher?: typeof fetch; guard?: Guard } = {},
 ): Promise<ResolvedLink | { error: string }> {
   const get = options.fetcher ?? fetch;
   const abort = new AbortController();
   const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? PLAYLIST_FETCH_TIMEOUT_MS);
   let text = "";
   try {
-    const answer = await get(url, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: "follow" });
+    // Followed here, one hop at a time, when there is a guard: a public
+    // address that redirects to the router is the router.
+    let at = url;
+    let answer: Response;
+    for (let hop = 0; ; hop += 1) {
+      if (options.guard) {
+        const refused = await options.guard(at);
+        if (refused) return { error: refused };
+      }
+      answer = await get(at, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: options.guard ? "manual" : "follow" });
+      const next = answer.headers.get("location");
+      if (!options.guard || answer.status < 300 || answer.status >= 400 || !next) break;
+      if (hop >= PLAYLIST_MAX_REDIRECTS) return { error: "that playlist redirects too many times" };
+      at = new URL(next, at).toString();
+    }
     if (!answer.ok) return { error: `that playlist could not be fetched (HTTP ${answer.status})` };
     text = (await answer.text()).slice(0, PLAYLIST_MAX_BYTES);
   } catch (error) {
@@ -493,10 +512,10 @@ export const RESOLVE_TIMEOUT_MS = 60_000;
 export async function resolveLink(
   ytdlp: string[] | null,
   url: string,
-  options: { cookies?: string; timeoutMs?: number; format?: string } = {},
+  options: { cookies?: string; timeoutMs?: number; format?: string; guard?: Guard } = {},
 ): Promise<ResolvedLink | { error: string }> {
   if (isDirectMedia(url)) return directLink(url);
-  if (isPlaylistLink(url)) return resolvePlaylist(url, { timeoutMs: options.timeoutMs });
+  if (isPlaylistLink(url)) return resolvePlaylist(url, { timeoutMs: options.timeoutMs, guard: options.guard });
   // Without yt-dlp, a link is taken as the media it may well be: an IPTV
   // feed has no extension and no page behind it, and ffprobe -- asked next,
   // before anything goes on the air -- tells a stream from a web page in a

package/src/main.ts

@@ -7,6 +7,7 @@ import { t as uiMessage, i18n, terminalUiLanguage, uiLanguage } from "./i18n.ts"
  *
  * ffmpeg decodes; we read every sample on its way to the speakers and draw it.
  */
+import { USAGE as STATION_USAGE } from "./station-usage.ts";
 import { createApp, themes, type BrailleCanvas, type Container, type KeyEvent, type Theme } from "@profullstack/hqtui";
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
@@ -232,6 +233,7 @@ keeps serving its browser remote. One per user.
 
   nixamp attach   put the player back in front of it
   nixamp admin    who is connected, and re-stream to them
+  nixamp station  make a folder into a station others can join (see: nixamp station help)
 
 From inside the player, d hands the music to a daemon without stopping it.
 `,
@@ -394,6 +396,7 @@ q or d leaves; neither stops anything. \`nixamp daemon stop\` is what stops it.
 };
 
 export function helpFor(topic: string | undefined): string {
+  if (topic === "station" || topic === "stations") return STATION_USAGE;
   return (topic ? TOPICS[topic] : undefined) ?? HELP;
 }
 
@@ -553,6 +556,11 @@ export async function main(): Promise<void> {
     process.exitCode = await runDaemon(rest);
     return;
   }
+  if (first === "station" || first === "stations") {
+    const { station } = await import("./station-cli.ts");
+    process.exitCode = await station(rest);
+    return;
+  }
   if (first === "admin") {
     const { admin } = await import("./admin.ts");
     await admin(rest);

package/src/playlist-input.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { protocolArgs } from "./decoder-policy.ts";
 import type { Readable } from "node:stream";
 import { codecsOf } from "./audio.ts";
 
@@ -11,24 +12,72 @@ export interface PlaylistInput {
   video: boolean;
   width?: number;
   height?: number;
+  /**
+   * Back to the top when the end is reached, instead of finishing: a
+   * station, which plays until somebody stops it.
+   */
+  repeat?: boolean;
+  /**
+   * The order to play a list of this length in, asked at the top of every
+   * pass: a station-wide shuffle is one order for everybody listening, drawn
+   * again each time round. Unset is the list's own order.
+   */
+  order?: (length: number) => number[];
+  /** Read at every entry boundary, so an edit to the list lands on the next track. */
+  current?: () => string[];
+  /** Entries already known not to play, passed over without being tried. */
+  excluded?: (file: string) => boolean;
+  /**
+   * Pass over an entry that will not play, instead of failing the stream.
+   * For a station, where the next track is what a listener should hear. A
+   * folder live leaves it unset: there a missing entry is usually a file
+   * still arriving, and the channel redials and waits for it.
+   */
+  passOver?: boolean;
+  /** Told when an entry is passed over because it would not play. */
+  onFailure?: (event: { at: number; file: string; reason: string }) => void;
 }
 
+/**
+ * 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
  * backpressure bounding read-ahead independently of the directory's size. */
 export class PlaylistInputStream {
-  private entries: { at: number; start: number; position: number }[] = [];
+  private entries: { at: number; file: string; start: number; position: number }[] = [];
   error: Error | null = null;
   complete = false;
   constructor(private readonly options: PlaylistInput) {}
 
+  /** Every entry that has started, in the order it started, with where it sits in the stream. */
+  get history(): ReadonlyArray<{ at: number; file: string; start: number; position: number }> {
+    return this.entries;
+  }
+
   place(seconds: number): { at: number; position: number } {
     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. */
+  private stopCurrent: (() => void) | null = null;
+  private skipping = false;
+
+  /** End the entry that is on and go to the next. False when nothing is on. */
+  skip(): boolean {
+    if (!this.stopCurrent) return false;
+    this.skipping = true;
+    this.stopCurrent();
+    return true;
+  }
+
   async *open(signal: AbortSignal): AsyncGenerator<Buffer> {
     const o = this.options;
     const [command, ...prefix] = o.ffmpeg as [string, ...string[]];
@@ -36,59 +85,132 @@ 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)]));
-        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<number | null>((resolve) => {
-          child.once("error", error => { tail = error.message; resolve(-1); });
-          child.once("close", code => resolve(code));
-        });
-        const abort = (): void => { child.kill("SIGKILL"); };
-        signal.addEventListener("abort", abort, { once: true });
-        try {
-          for await (const chunk of child.stdout as Readable) {
+      const orderFor = (list: string[]): number[] =>
+        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) 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 as Buffer;
+            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] as Readable | null)?.on("data", (chunk: Buffer) => {
+              const found = /out_time_us=(\d+)/g;
+              let match: RegExpExecArray | null;
+              while ((match = found.exec(chunk.toString())) !== null) reached = Math.max(reached, Number(match[1]) / 1e6);
+            });
+            const closed = new Promise<number | null>((resolve) => {
+              child.once("error", error => { tail = error.message; resolve(-1); });
+              child.once("close", code => resolve(code));
+            });
+            const abort = (): void => { child.kill("SIGKILL"); };
+            signal.addEventListener("abort", abort, { once: true });
+            this.stopCurrent = abort;
+            let skipped = false;
+            try {
+              for await (const chunk of child.stdout as Readable) {
+                if (signal.aborted) return;
+                yield chunk as Buffer;
+              }
+              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;
     } catch (error) {

package/src/publish-choice.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 function publishChoice(
+  flag: PublishFlag,
+  recorded: boolean | undefined,
+  interactive: boolean,
+  established: boolean,
+): "yes" | "no" | "ask" {
+  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: PublishFlag, recorded: boolean | undefined): boolean {
+  return flag === "ask" && recorded === undefined;
+}