nixamp 0.5.9 → 0.5.11

package/dist/attach.js

@@ -23,7 +23,11 @@ import { KEY_HEADER } from "./share.js";
 const RECONNECT_MS = 1000;
 /** A remote track has no path, because no filesystem path leaves the machine. */
 export function applySnapshot(state, snapshot) {
-    state.tracks = snapshot.tracks.map((track) => ({ path: "", ...track }));
+    // A frame without a list is not an empty library, it is a frame with nothing
+    // new to say about it -- which is every frame but the first.
+    if (snapshot.tracks !== undefined) {
+        state.tracks = snapshot.tracks.map((track) => ({ path: "", ...track }));
+    }
     state.index = snapshot.index;
     state.playing = snapshot.playing;
     state.position = snapshot.position;

package/dist/audio.d.ts

@@ -58,3 +58,28 @@ export declare function peaks(pcm: Float32Array): [number, number];
 /** Interleaved stereo down to mono, for the analyser. */
 export declare function toMono(pcm: Float32Array): Float32Array;
 export declare function formatTime(seconds: number): string;
+/** What is actually inside a container, as opposed to what the name suggests. */
+export interface Codecs {
+    /** e.g. "h264", "hevc", "vp9". Empty when there is no video stream. */
+    video: string;
+    /** e.g. "aac", "ac3", "dts". Empty when there is no audio stream. */
+    audio: string;
+}
+/**
+ * Ask ffprobe what the streams are, without holding the event loop.
+ *
+ * Deliberately not the spawnSync `probe` above: this one runs while a server is
+ * 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): Promise<Codecs>;
+/**
+ * How to get this file into a browser, given what is inside it.
+ *
+ * A container a browser will not open says nothing about the streams within:
+ * most Matroska holds H.264, which every browser decodes, and only the wrapper
+ * is wrong. Rewrapping that costs nothing and looks identical; re-encoding it
+ * would cost a core per viewer and look worse. So the streams decide, one part
+ * at a time -- a film can have its video copied and only its DTS re-encoded.
+ */
+export declare function videoArgs(codecs: Codecs): string[];

package/dist/audio.js

@@ -204,3 +204,68 @@ export function formatTime(seconds) {
     const s = total % 60;
     return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
 }
+/**
+ * Ask ffprobe what the streams are, without holding the event loop.
+ *
+ * Deliberately not the spawnSync `probe` above: this one runs while a server is
+ * 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) {
+    const [cmd, ...rest] = tools.ffprobe;
+    const empty = { video: "", audio: "" };
+    if (!cmd)
+        return empty;
+    return new Promise((done) => {
+        const child = spawn(cmd, [
+            ...rest,
+            "-v", "quiet",
+            "-print_format", "json",
+            "-show_entries", "stream=codec_type,codec_name",
+            path,
+        ], { stdio: ["ignore", "pipe", "ignore"] });
+        let out = "";
+        child.stdout.on("data", (chunk) => {
+            out += chunk.toString("utf8");
+        });
+        child.on("error", () => done(empty));
+        child.on("close", () => {
+            try {
+                const parsed = JSON.parse(out);
+                const streams = parsed.streams ?? [];
+                return done({
+                    video: streams.find((s) => s.codec_type === "video")?.codec_name ?? "",
+                    audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
+                });
+            }
+            catch {
+                return done(empty);
+            }
+        });
+    });
+}
+/**
+ * How to get this file into a browser, given what is inside it.
+ *
+ * A container a browser will not open says nothing about the streams within:
+ * most Matroska holds H.264, which every browser decodes, and only the wrapper
+ * is wrong. Rewrapping that costs nothing and looks identical; re-encoding it
+ * would cost a core per viewer and look worse. So the streams decide, one part
+ * at a time -- a film can have its video copied and only its DTS re-encoded.
+ */
+export function videoArgs(codecs) {
+    // What a browser can play inside MP4 without help.
+    const keepVideo = codecs.video === "h264";
+    const keepAudio = codecs.audio === "aac" || codecs.audio === "mp3";
+    return [
+        "-c:v", keepVideo ? "copy" : "libx264",
+        ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),
+        "-c:a", keepAudio ? "copy" : "aac",
+        ...(keepAudio ? [] : ["-b:a", "160k", "-ac", "2"]),
+        "-f", "mp4",
+        // Fragmented, because this is a pipe: a normal MP4 writes its index at the
+        // end, which for a stream never arrives and for a browser means nothing
+        // plays at all.
+        "-movflags", "frag_keyframe+empty_moov+default_base_moof",
+    ];
+}

package/dist/protocol.d.ts

@@ -25,7 +25,24 @@ export interface RemoteTrack {
 export interface Snapshot {
     /** Bumped on every push so a client can drop an out-of-order frame. */
     revision: number;
-    tracks: RemoteTrack[];
+    /**
+     * The library, sent when it is news and left out when it is not.
+     *
+     * It used to ride in every frame. At twelve frames a second over a library of
+     * five thousand, that is five megabytes a second of JSON for a client to
+     * parse on the thread that is also decoding the audio -- which is exactly
+     * what it sounded like. It is sent on the first frame of a subscription and
+     * again whenever the list actually changes; absent means "the same as
+     * before", and a client keeps what it had.
+     */
+    tracks?: RemoteTrack[];
+    /**
+     * How many tracks there are, in every frame.
+     *
+     * A client that has not received a list yet still has to draw something, and
+     * a count is four bytes rather than half a megabyte.
+     */
+    trackCount: number;
     index: number;
     playing: boolean;
     position: number;
@@ -61,4 +78,19 @@ export declare const COMMAND_TYPES: readonly ["play", "toggle", "stop", "next",
 export declare function parseCommand(input: unknown): Command | null;
 /** The name a remote shows for a track. */
 export declare function remoteName(track: RemoteTrack): string;
-export declare function emptySnapshot(): Snapshot;
+export declare function emptySnapshot(): FullSnapshot;
+/**
+ * Fold a frame into what the client already had.
+ *
+ * A frame without `tracks` is not a frame with no tracks: it is a frame that
+ * had nothing new to say about them. Every client needs this, so none of them
+ * should write it twice.
+ */
+export declare function merge(previous: FullSnapshot, incoming: Snapshot): FullSnapshot;
+/**
+ * A snapshot a client has already folded, so the library is known to be there.
+ * Every reader wants this one; only the wire carries the other.
+ */
+export type FullSnapshot = Snapshot & {
+    tracks: RemoteTrack[];
+};

package/dist/protocol.js

@@ -41,6 +41,7 @@ export function emptySnapshot() {
     return {
         revision: 0,
         tracks: [],
+        trackCount: 0,
         index: 0,
         playing: false,
         position: 0,
@@ -51,3 +52,13 @@ export function emptySnapshot() {
         root: "",
     };
 }
+/**
+ * Fold a frame into what the client already had.
+ *
+ * A frame without `tracks` is not a frame with no tracks: it is a frame that
+ * had nothing new to say about them. Every client needs this, so none of them
+ * should write it twice.
+ */
+export function merge(previous, incoming) {
+    return { ...incoming, tracks: incoming.tracks ?? previous.tracks };
+}

package/dist/server.d.ts

@@ -111,7 +111,8 @@ export declare function parseRange(header: string | undefined, size: number): By
 export declare function safeJoin(rootDir: string, urlPath: string): string | null;
 /** What the HTTP layer needs from a player. Tests hand it a fake. */
 export interface Engine {
-    snapshot(): Snapshot;
+    /** `withTracks` false leaves the library out, for a frame that is only motion. */
+    snapshot(withTracks?: boolean): Snapshot;
     command(command: Command): void;
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
     /** Absolute path of a track, or undefined when the index is not one. */
@@ -161,7 +162,11 @@ export declare class PlayerEngine implements Engine {
     fps?: number);
     private readonly silent;
     private consume;
-    snapshot(): Snapshot;
+    /**
+     * The current state. `withTracks` carries the library, which is worth half a
+     * megabyte on a real one and is only news when it has changed.
+     */
+    snapshot(withTracks?: boolean): Snapshot;
     trackPath(index: number): string | undefined;
     command(command: Command): void;
     private clamp;
@@ -169,6 +174,13 @@ export declare class PlayerEngine implements Engine {
     private start;
     private halt;
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
+    /**
+     * Send the state to everyone watching.
+     *
+     * The library goes only when `listChanged` says it has, which is what turned
+     * five megabytes a second into a few kilobytes: an analyser tick has nothing
+     * to say about the track list, and it fires twelve times a second.
+     */
     private push;
     stop(): void;
     replace(tracks: Track[], root: string): void;
@@ -205,6 +217,8 @@ export interface HandlerOptions {
     listenKey?: string | null;
     /** How to run ffmpeg, for the sources a browser cannot play by itself. */
     ffmpeg?: string[];
+    /** Where ffprobe is, for asking what is inside a file before re-encoding it. */
+    ffprobe?: string[];
     /** Who is listening, for the admin view. */
     connections?: Connections;
     /**

package/dist/server.js

@@ -35,6 +35,7 @@ import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
 import { isRemote, playsInBrowser } from "./sources.js";
+import { codecsOf, videoArgs } from "./audio.js";
 import { allowedForListening, elevate, firewallInUse, keyCookie, keyFrom, lookupPublicIp, newKey, portCommands, reachableAddresses, scopeOf, shareLink, audioLink, } from "./share.js";
 import { extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -347,10 +348,15 @@ export class PlayerEngine {
         this.pending = joined.subarray(at);
         this.dirty = true;
     }
-    snapshot() {
+    /**
+     * The current state. `withTracks` carries the library, which is worth half a
+     * megabyte on a real one and is only news when it has changed.
+     */
+    snapshot(withTracks = true) {
         return {
             revision: this.revision,
-            tracks: toRemoteTracks(this.tracks),
+            ...(withTracks ? { tracks: toRemoteTracks(this.tracks) } : {}),
+            trackCount: this.tracks.length,
             index: this.state.index,
             playing: this.state.playing,
             position: this.state.position,
@@ -444,11 +450,18 @@ export class PlayerEngine {
             }
         };
     }
-    push() {
+    /**
+     * Send the state to everyone watching.
+     *
+     * The library goes only when `listChanged` says it has, which is what turned
+     * five megabytes a second into a few kilobytes: an analyser tick has nothing
+     * to say about the track list, and it fires twelve times a second.
+     */
+    push(listChanged = false) {
         this.revision++;
         if (this.listeners.size === 0)
             return;
-        const snapshot = this.snapshot();
+        const snapshot = this.snapshot(listChanged);
         for (const listener of this.listeners)
             listener(snapshot);
     }
@@ -467,7 +480,7 @@ export class PlayerEngine {
         this.state.index = 0;
         this.state.position = 0;
         this.state.note = "";
-        this.push();
+        this.push(true);
     }
     retag(tracks, root) {
         // Dropped rather than applied if the library moved underneath: somebody
@@ -479,8 +492,9 @@ export class PlayerEngine {
             return;
         this.tracks = tracks;
         // No stop, no index reset: the only thing that changes is what the titles
-        // say, and every remote finds out because a snapshot goes out.
-        this.push();
+        // say, and every remote finds out because a snapshot goes out -- carrying
+        // the list, since the titles are the whole point of this one.
+        this.push(true);
     }
 }
 /** An engine with no library behind it, for the hosted PWA. */
@@ -1539,15 +1553,24 @@ export function createHandler(engine, options) {
                 json(response, 404, { error: "no such track" });
                 return;
             }
-            watch(request, response, "media", engine.snapshot().tracks[index]?.title ?? file);
+            watch(request, response, "media", engine.snapshot().tracks?.[index]?.title ?? file);
             // A browser asks for every track here, and a matroska or an avi handed
             // to it raw is bytes it cannot play. Seeking is what this route is for
             // and transcoding gives it up, but an unseekable film beats a silent
             // one -- and the seekable formats are untouched.
-            if (playsInBrowser(file))
+            if (playsInBrowser(file)) {
                 sendFile(request, response, file);
-            else
+            }
+            else if (hasPicture(file)) {
+                // A film. It used to arrive as MP3 with `-vn`, which is to say as a
+                // soundtrack over a blank panel; what ffprobe finds inside decides how
+                // little work it takes to keep the picture.
+                const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, file);
+                pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs), "video/mp4");
+            }
+            else {
                 transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
+            }
             return;
         }
         // Whatever the source is, this comes back as MP3 a browser will play:
@@ -1562,11 +1585,11 @@ export function createHandler(engine, options) {
                 return;
             }
             const current = engine.snapshot();
-            if (current.tracks.length === 0) {
+            if (current.trackCount === 0) {
                 json(response, 404, { error: "nothing is playing" });
                 return;
             }
-            watch(request, response, "stream", current.tracks[current.index]?.title ?? "live");
+            watch(request, response, "stream", current.tracks?.[current.index]?.title ?? "live");
             liveAudio(request, response, engine, options.ffmpeg ?? ["ffmpeg"]);
             return;
         }
@@ -1581,7 +1604,7 @@ export function createHandler(engine, options) {
                 json(response, 403, { error: "media streaming is off" });
                 return;
             }
-            watch(request, response, "stream", engine.snapshot().tracks[index]?.title ?? source);
+            watch(request, response, "stream", engine.snapshot().tracks?.[index]?.title ?? source);
             transcode(request, response, source, options.ffmpeg ?? ["ffmpeg"]);
             return;
         }
@@ -1748,7 +1771,18 @@ function liveAudio(request, response, engine, ffmpeg) {
  * player falls back to /api/media for a local file it can seek, and uses this
  * for everything else.
  */
+/** Audio, from whatever this is: the shape every non-browser source took. */
 function transcode(request, response, source, ffmpeg) {
+    pipeFfmpeg(request, response, source, ffmpeg, ["-vn", "-f", "mp3", "-b:a", "192k"], "audio/mpeg");
+}
+/**
+ * Run ffmpeg and hand its output straight to the caller.
+ *
+ * The output arguments belong to the caller, because the same plumbing carries
+ * a film and a song and the only difference is what ffmpeg is asked to write --
+ * which for a film is decided by what ffprobe found inside it.
+ */
+function pipeFfmpeg(request, response, source, ffmpeg, outputArgs, contentType) {
     const [command, ...prefix] = ffmpeg;
     const child = spawn(command, [
         ...prefix,
@@ -1759,9 +1793,7 @@ function transcode(request, response, source, ffmpeg) {
         // when they are handed to it for a file on disk.
         ...(isRemote(source) ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
         "-i", source,
-        "-vn",
-        "-f", "mp3",
-        "-b:a", "192k",
+        ...outputArgs,
         "-",
     ], { stdio: ["ignore", "pipe", "pipe"] });
     let failed = "";
@@ -1776,7 +1808,7 @@ function transcode(request, response, source, ffmpeg) {
         started = true;
         response.writeHead(200, {
             ...CORS,
-            "content-type": "audio/mpeg",
+            "content-type": contentType,
             "cache-control": "no-store",
             // Length is unknowable up front, and a browser is happy without it.
             "transfer-encoding": "chunked",
@@ -2094,6 +2126,7 @@ export async function serve(argv, version = "0.1.0") {
         connections,
         paywall,
         ffmpeg: tools.ffmpeg,
+        ffprobe: tools.ffprobe,
         load: (next) => loadSource(tools, next),
         ...(directory ? { directory } : {}),
         ...(follows ? { follows, vapidPublicKey } : {}),
@@ -2321,7 +2354,7 @@ export async function serve(argv, version = "0.1.0") {
                 },
                 nowPlaying: () => {
                     const snapshot = engine.snapshot();
-                    return snapshot.tracks[snapshot.index]?.title ?? "";
+                    return snapshot.tracks?.[snapshot.index]?.title ?? "";
                 },
                 onConfig: (remote) => {
                     const next = applyRemoteConfig(paywallConfig, remote?.x402);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/attach.ts

@@ -26,7 +26,11 @@ const RECONNECT_MS = 1000;
 
 /** A remote track has no path, because no filesystem path leaves the machine. */
 export function applySnapshot(state: State, snapshot: Snapshot): void {
-  state.tracks = snapshot.tracks.map((track) => ({ path: "", ...track }));
+  // A frame without a list is not an empty library, it is a frame with nothing
+  // new to say about it -- which is every frame but the first.
+  if (snapshot.tracks !== undefined) {
+    state.tracks = snapshot.tracks.map((track) => ({ path: "", ...track }));
+  }
   state.index = snapshot.index;
   state.playing = snapshot.playing;
   state.position = snapshot.position;

package/src/audio.ts

@@ -231,3 +231,81 @@ export function formatTime(seconds: number): string {
   const s = total % 60;
   return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
 }
+
+/** What is actually inside a container, as opposed to what the name suggests. */
+export interface Codecs {
+  /** e.g. "h264", "hevc", "vp9". Empty when there is no video stream. */
+  video: string;
+  /** e.g. "aac", "ac3", "dts". Empty when there is no audio stream. */
+  audio: string;
+}
+
+/**
+ * Ask ffprobe what the streams are, without holding the event loop.
+ *
+ * Deliberately not the spawnSync `probe` above: this one runs while a server is
+ * 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: Tools, path: string): Promise<Codecs> {
+  const [cmd, ...rest] = tools.ffprobe;
+  const empty: Codecs = { video: "", audio: "" };
+  if (!cmd) return empty;
+
+  return new Promise<Codecs>((done) => {
+    const child = spawn(
+      cmd,
+      [
+        ...rest,
+        "-v", "quiet",
+        "-print_format", "json",
+        "-show_entries", "stream=codec_type,codec_name",
+        path,
+      ],
+      { stdio: ["ignore", "pipe", "ignore"] },
+    );
+    let out = "";
+    child.stdout.on("data", (chunk: Buffer) => {
+      out += chunk.toString("utf8");
+    });
+    child.on("error", () => done(empty));
+    child.on("close", () => {
+      try {
+        const parsed = JSON.parse(out) as { streams?: { codec_type?: string; codec_name?: string }[] };
+        const streams = parsed.streams ?? [];
+        return done({
+          video: streams.find((s) => s.codec_type === "video")?.codec_name ?? "",
+          audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
+        });
+      } catch {
+        return done(empty);
+      }
+    });
+  });
+}
+
+/**
+ * How to get this file into a browser, given what is inside it.
+ *
+ * A container a browser will not open says nothing about the streams within:
+ * most Matroska holds H.264, which every browser decodes, and only the wrapper
+ * is wrong. Rewrapping that costs nothing and looks identical; re-encoding it
+ * would cost a core per viewer and look worse. So the streams decide, one part
+ * at a time -- a film can have its video copied and only its DTS re-encoded.
+ */
+export function videoArgs(codecs: Codecs): string[] {
+  // What a browser can play inside MP4 without help.
+  const keepVideo = codecs.video === "h264";
+  const keepAudio = codecs.audio === "aac" || codecs.audio === "mp3";
+  return [
+    "-c:v", keepVideo ? "copy" : "libx264",
+    ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),
+    "-c:a", keepAudio ? "copy" : "aac",
+    ...(keepAudio ? [] : ["-b:a", "160k", "-ac", "2"]),
+    "-f", "mp4",
+    // Fragmented, because this is a pipe: a normal MP4 writes its index at the
+    // end, which for a stream never arrives and for a browser means nothing
+    // plays at all.
+    "-movflags", "frag_keyframe+empty_moov+default_base_moof",
+  ];
+}

package/src/protocol.ts

@@ -27,7 +27,24 @@ export interface RemoteTrack {
 export interface Snapshot {
   /** Bumped on every push so a client can drop an out-of-order frame. */
   revision: number;
-  tracks: RemoteTrack[];
+  /**
+   * The library, sent when it is news and left out when it is not.
+   *
+   * It used to ride in every frame. At twelve frames a second over a library of
+   * five thousand, that is five megabytes a second of JSON for a client to
+   * parse on the thread that is also decoding the audio -- which is exactly
+   * what it sounded like. It is sent on the first frame of a subscription and
+   * again whenever the list actually changes; absent means "the same as
+   * before", and a client keeps what it had.
+   */
+  tracks?: RemoteTrack[];
+  /**
+   * How many tracks there are, in every frame.
+   *
+   * A client that has not received a list yet still has to draw something, and
+   * a count is four bytes rather than half a megabyte.
+   */
+  trackCount: number;
   index: number;
   playing: boolean;
   position: number;
@@ -83,10 +100,11 @@ export function remoteName(track: RemoteTrack): string {
   return track.artist ? `${track.artist} — ${track.title}` : track.title;
 }
 
-export function emptySnapshot(): Snapshot {
+export function emptySnapshot(): FullSnapshot {
   return {
     revision: 0,
     tracks: [],
+    trackCount: 0,
     index: 0,
     playing: false,
     position: 0,
@@ -97,3 +115,20 @@ export function emptySnapshot(): Snapshot {
     root: "",
   };
 }
+
+/**
+ * Fold a frame into what the client already had.
+ *
+ * A frame without `tracks` is not a frame with no tracks: it is a frame that
+ * had nothing new to say about them. Every client needs this, so none of them
+ * should write it twice.
+ */
+export function merge(previous: FullSnapshot, incoming: Snapshot): FullSnapshot {
+  return { ...incoming, tracks: incoming.tracks ?? previous.tracks };
+}
+
+/**
+ * A snapshot a client has already folded, so the library is known to be there.
+ * Every reader wants this one; only the wire carries the other.
+ */
+export type FullSnapshot = Snapshot & { tracks: RemoteTrack[] };