nixamp 0.5.8 → 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/protocol.d.ts

@@ -12,6 +12,14 @@ export interface RemoteTrack {
     album: string;
     /** Seconds; 0 when ffprobe could not tell us. */
     duration: number;
+    /**
+     * Whether this is a film rather than a song.
+     *
+     * The server knows, because it has the path; a remote had been guessing, and
+     * guessing wrong -- every remote track went to the audio element, so a video
+     * a browser could show played its soundtrack over a blank panel.
+     */
+    video?: boolean;
 }
 /** Everything a remote needs to draw the player. */
 export interface Snapshot {

package/dist/server.d.ts

@@ -135,6 +135,7 @@ export interface Engine {
     stop(): void;
 }
 export declare function toRemoteTracks(tracks: Track[]): RemoteTrack[];
+export declare function hasPicture(path: string): boolean;
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -204,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";
@@ -269,8 +270,18 @@ export function toRemoteTracks(tracks) {
         artist: t.artist,
         album: t.album,
         duration: t.duration,
+        // Said out loud, because a remote cannot see the path and had been sending
+        // every track to the audio element -- a film's soundtrack over a blank
+        // panel, which is exactly what it looked like.
+        ...(hasPicture(t.path) ? { video: true } : {}),
     }));
 }
+/** Video containers, as opposed to the songs that are most of a library. */
+const PICTURE = new Set([".mp4", ".mkv", ".avi", ".mov", ".m4v", ".webm", ".mpg", ".mpeg", ".wmv", ".flv"]);
+export function hasPicture(path) {
+    const dot = path.lastIndexOf(".");
+    return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
+}
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -1534,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:
@@ -1738,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,
@@ -1749,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 = "";
@@ -1766,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",
@@ -2084,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.8",
+  "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/protocol.ts

@@ -13,6 +13,14 @@ export interface RemoteTrack {
   album: string;
   /** Seconds; 0 when ffprobe could not tell us. */
   duration: number;
+  /**
+   * Whether this is a film rather than a song.
+   *
+   * The server knows, because it has the path; a remote had been guessing, and
+   * guessing wrong -- every remote track went to the audio element, so a video
+   * a browser could show played its soundtrack over a blank panel.
+   */
+  video?: boolean;
 }
 
 /** Everything a remote needs to draw the player. */

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,
@@ -391,9 +392,21 @@ export function toRemoteTracks(tracks: Track[]): RemoteTrack[] {
     artist: t.artist,
     album: t.album,
     duration: t.duration,
+    // Said out loud, because a remote cannot see the path and had been sending
+    // every track to the audio element -- a film's soundtrack over a blank
+    // panel, which is exactly what it looked like.
+    ...(hasPicture(t.path) ? { video: true } : {}),
   }));
 }
 
+/** Video containers, as opposed to the songs that are most of a library. */
+const PICTURE = new Set([".mp4", ".mkv", ".avi", ".mov", ".m4v", ".webm", ".mpg", ".mpeg", ".wmv", ".flv"]);
+
+export function hasPicture(path: string): boolean {
+  const dot = path.lastIndexOf(".");
+  return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
+}
+
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -681,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;
   /**
@@ -1801,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;
     }
 
@@ -2017,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(
@@ -2035,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"] },
@@ -2055,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",
@@ -2392,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/assets/hls-3VKVEQE3-Cj5Lwh7A.js

@@ -0,0 +1 @@
+import{t as e}from"./index-ABOb54bx.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};