nixamp 0.5.9 → 0.5.10

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/server.d.ts

@@ -205,6 +205,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";
@@ -1544,10 +1545,19 @@ export function createHandler(engine, options) {
             // 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:
@@ -1748,7 +1758,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 +1780,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 +1795,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 +2113,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 } : {}),

package/package.json

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

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/server.ts

@@ -55,6 +55,7 @@ import {
   paywallFromEnv,
 } from "./paywall.ts";
 import { isRemote, playsInBrowser } from "./sources.ts";
+import { codecsOf, videoArgs } from "./audio.ts";
 import {
   allowedForListening,
   elevate,
@@ -693,6 +694,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;
   /**
@@ -1813,8 +1816,17 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       // 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)) sendFile(request, response, file);
-      else transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
+      if (playsInBrowser(file)) {
+        sendFile(request, response, file);
+      } 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;
     }
 
@@ -2029,11 +2041,30 @@ function liveAudio(
  * 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: IncomingMessage,
   response: ServerResponse,
   source: string,
   ffmpeg: string[],
+): void {
+  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: IncomingMessage,
+  response: ServerResponse,
+  source: string,
+  ffmpeg: string[],
+  outputArgs: string[],
+  contentType: string,
 ): void {
   const [command, ...prefix] = ffmpeg as [string, ...string[]];
   const child = spawn(
@@ -2047,9 +2078,7 @@ function transcode(
       // 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"] },
@@ -2067,7 +2096,7 @@ function transcode(
     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",
@@ -2404,6 +2433,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     connections,
     paywall,
     ffmpeg: tools.ffmpeg,
+    ffprobe: tools.ffprobe,
     load: (next) => loadSource(tools, next),
     ...(directory ? { directory } : {}),
     ...(follows ? { follows, vapidPublicKey } : {}),

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1788941457384";
+const CACHE = "nixamp-1788942007074";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",