nixamp 0.10.2 → 0.10.3

package/dist/audio.js

@@ -408,7 +408,11 @@ export function videoArgs(codecs, capKbps = 0) {
     const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
     return [
         "-c:v", keepVideo ? "copy" : "libx264",
-        ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),
+        // A keyframe every two seconds when encoding. A fragment starts on a
+        // keyframe, so this is how soon a joiner sees a picture -- and an HLS
+        // segment, which is cut on keyframes too, was ten seconds long on
+        // x264's default and made a phone wait thirty before it played.
+        ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p", "-g", "48", "-keyint_min", "48", "-sc_threshold", "0"]),
         "-c:a", keepAudio ? "copy" : "aac",
         ...(keepAudio ? [] : ["-b:a", "160k", "-ac", "2"]),
         "-f", "mp4",

package/dist/hls.d.ts

@@ -0,0 +1,55 @@
+/** Seconds of video per segment. Short, so joining is quick; long enough that a playlist is not churn. */
+export declare const SEGMENT_SECONDS = 2;
+/** How many segments the playlist offers. About twelve seconds of catch-up. */
+export declare const PLAYLIST_SEGMENTS = 6;
+/** How long a packager runs with nobody asking for its playlist. */
+export declare const IDLE_MS = 60000;
+/** How long the first playlist may take to appear before it is a failure. */
+export declare const FIRST_PLAYLIST_MS = 20000;
+/** A segment file name, or "" for anything that is not one. Never a path. */
+export declare function segmentName(requested: string): string;
+/**
+ * The playlist with the key on every segment.
+ *
+ * A browser resolves segment names against the playlist's URL and drops its
+ * query, so the key that opened the playlist never reaches the segments and
+ * each one answers 401. The key travels on every line instead.
+ */
+export declare function withKey(playlist: string, key: string): string;
+/** The ffmpeg arguments: copy what arrives on stdin into a rolling playlist. */
+export declare function packagerArgs(dir: string): string[];
+export interface Packaged {
+    /** Feed it the channel's bytes: the header first, then every fragment. */
+    write(chunk: Buffer): boolean;
+    /** The channel ended; finish and stop. */
+    end(): void;
+}
+/**
+ * The packagers, one per channel that somebody is watching this way.
+ *
+ * `listen` is how a packager becomes a listener on its channel: it is handed
+ * the header and then every fragment, exactly as a browser would be.
+ */
+export declare class HlsPackagers {
+    private readonly options;
+    private readonly running;
+    constructor(options: {
+        ffmpeg: string[];
+        listen: (id: string, listener: Packaged) => (() => void) | null;
+        onEvent?: (message: string) => void;
+        /** Injected for tests: how long to wait for the first playlist. */
+        firstPlaylistMs?: number;
+    });
+    /**
+     * The playlist for a channel, starting the packager if it is not running,
+     * and waiting for the first segments to exist. Null when the channel is not
+     * there or nothing could be packaged.
+     */
+    playlist(id: string): Promise<string | null>;
+    /** A segment's path, or "" when there is no such segment. */
+    segment(id: string, name: string): string;
+    /** The channel went: stop packaging it. */
+    stop(id: string): void;
+    stopAll(): void;
+    get count(): number;
+}

package/dist/hls.js

@@ -0,0 +1,254 @@
+/**
+ * A channel as HLS, for the browsers that will not take it any other way.
+ *
+ * A channel is sent as one endless fragmented MP4 down a chunked response,
+ * which Chrome and Firefox play as they would a file. Safari on an iPhone
+ * will not: it asks for a byte range, gets a stream with no length, and gives
+ * up before the first picture -- a spinner that flashes and a player that
+ * never starts. What Safari plays live is HLS, a playlist of short files.
+ *
+ * So this packages the same bytes into HLS on demand: one ffmpeg per channel,
+ * copying (never re-encoding) the fragments it is fed into two-second
+ * MPEG-TS segments in a temporary directory, started when the first playlist
+ * is asked for and stopped a minute after the last. The channel itself is
+ * untouched; this is one more listener on it.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Seconds of video per segment. Short, so joining is quick; long enough that a playlist is not churn. */
+export const SEGMENT_SECONDS = 2;
+/** How many segments the playlist offers. About twelve seconds of catch-up. */
+export const PLAYLIST_SEGMENTS = 6;
+/** How long a packager runs with nobody asking for its playlist. */
+export const IDLE_MS = 60_000;
+/** How long the first playlist may take to appear before it is a failure. */
+export const FIRST_PLAYLIST_MS = 20_000;
+const SEGMENT = /^seg\d{5}\.ts$/;
+/** A segment file name, or "" for anything that is not one. Never a path. */
+export function segmentName(requested) {
+    return SEGMENT.test(requested) ? requested : "";
+}
+/**
+ * The playlist with the key on every segment.
+ *
+ * A browser resolves segment names against the playlist's URL and drops its
+ * query, so the key that opened the playlist never reaches the segments and
+ * each one answers 401. The key travels on every line instead.
+ */
+export function withKey(playlist, key) {
+    if (key === "")
+        return playlist;
+    return playlist
+        .split("\n")
+        .map((line) => (line !== "" && !line.startsWith("#") ? `${line}?k=${encodeURIComponent(key)}` : line))
+        .join("\n");
+}
+/** The ffmpeg arguments: copy what arrives on stdin into a rolling playlist. */
+export function packagerArgs(dir) {
+    return [
+        "-hide_banner",
+        "-loglevel", "error",
+        "-i", "pipe:0",
+        "-c", "copy",
+        "-f", "hls",
+        "-hls_time", String(SEGMENT_SECONDS),
+        "-hls_list_size", String(PLAYLIST_SEGMENTS),
+        // Old segments go; the playlist never ends; each segment starts on a
+        // keyframe so a joiner can begin anywhere; written whole then renamed so
+        // a request never reads half a file.
+        "-hls_flags", "delete_segments+omit_endlist+independent_segments+temp_file",
+        "-hls_segment_type", "mpegts",
+        "-hls_segment_filename", join(dir, "seg%05d.ts"),
+        join(dir, "index.m3u8"),
+    ];
+}
+/** One channel's packager. */
+class Packager {
+    id;
+    ffmpeg;
+    onStop;
+    onEvent;
+    dir;
+    child = null;
+    idle = null;
+    stopped = false;
+    detach = null;
+    constructor(id, ffmpeg, onStop, onEvent) {
+        this.id = id;
+        this.ffmpeg = ffmpeg;
+        this.onStop = onStop;
+        this.onEvent = onEvent;
+        this.dir = mkdtempSync(join(tmpdir(), `nixamp-hls-${id}-`));
+    }
+    start(listen) {
+        const [command, ...prefix] = this.ffmpeg;
+        try {
+            this.child = spawn(command, [...prefix, ...packagerArgs(this.dir)], { stdio: ["pipe", "ignore", "pipe"] });
+        }
+        catch (error) {
+            this.onEvent(`  HLS for "${this.id}" could not start: ${error.message}`);
+            this.stop();
+            return false;
+        }
+        let complaint = "";
+        this.child.stderr?.on("data", (chunk) => {
+            if (complaint.length < 4000)
+                complaint += chunk.toString("utf8");
+        });
+        this.child.stdin?.on("error", () => undefined);
+        this.child.on("error", (error) => {
+            this.onEvent(`  HLS for "${this.id}" failed: ${error.message}`);
+            this.stop();
+        });
+        this.child.on("close", (code) => {
+            if (!this.stopped && code !== 0) {
+                this.onEvent(`  HLS for "${this.id}" stopped: ${complaint.trim().split("\n").pop() ?? code}`);
+            }
+            this.stop();
+        });
+        this.detach = listen(this);
+        if (this.detach === null) {
+            this.stop();
+            return false;
+        }
+        this.touch();
+        return true;
+    }
+    write(chunk) {
+        const stdin = this.child?.stdin;
+        if (!stdin || stdin.destroyed)
+            return false;
+        try {
+            stdin.write(chunk);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    end() {
+        try {
+            this.child?.stdin?.end();
+        }
+        catch {
+            // Already gone.
+        }
+        this.stop();
+    }
+    /** Somebody asked for the playlist: it is wanted for another minute. */
+    touch() {
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = setTimeout(() => this.stop(), IDLE_MS);
+        this.idle.unref?.();
+    }
+    /** The playlist as it stands, or "" before the first segment is written. */
+    playlist() {
+        try {
+            const text = readFileSync(join(this.dir, "index.m3u8"), "utf8");
+            return text.includes("#EXTINF") ? text : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    /** A segment's path, or "" when it is not there (any more). */
+    segment(name) {
+        const safe = segmentName(name);
+        if (safe === "")
+            return "";
+        const path = join(this.dir, safe);
+        try {
+            return statSync(path).isFile() ? path : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = null;
+        this.detach?.();
+        this.detach = null;
+        const child = this.child;
+        this.child = null;
+        if (child && child.exitCode === null) {
+            try {
+                child.stdin?.end();
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+        }
+        try {
+            rmSync(this.dir, { recursive: true, force: true });
+        }
+        catch {
+            // A directory that is already gone is fine.
+        }
+        this.onStop(this.id);
+    }
+}
+/**
+ * The packagers, one per channel that somebody is watching this way.
+ *
+ * `listen` is how a packager becomes a listener on its channel: it is handed
+ * the header and then every fragment, exactly as a browser would be.
+ */
+export class HlsPackagers {
+    options;
+    running = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * The playlist for a channel, starting the packager if it is not running,
+     * and waiting for the first segments to exist. Null when the channel is not
+     * there or nothing could be packaged.
+     */
+    async playlist(id) {
+        let packager = this.running.get(id);
+        if (!packager) {
+            packager = new Packager(id, this.options.ffmpeg, (gone) => this.running.delete(gone), this.options.onEvent ?? (() => undefined));
+            this.running.set(id, packager);
+            if (!packager.start((listener) => this.options.listen(id, listener)))
+                return null;
+        }
+        packager.touch();
+        const deadline = Date.now() + (this.options.firstPlaylistMs ?? FIRST_PLAYLIST_MS);
+        for (;;) {
+            const text = packager.playlist();
+            if (text !== "")
+                return text;
+            if (Date.now() > deadline || !this.running.has(id))
+                return null;
+            await new Promise((done) => setTimeout(done, 250));
+        }
+    }
+    /** A segment's path, or "" when there is no such segment. */
+    segment(id, name) {
+        const packager = this.running.get(id);
+        if (!packager)
+            return "";
+        packager.touch();
+        return packager.segment(name);
+    }
+    /** The channel went: stop packaging it. */
+    stop(id) {
+        this.running.get(id)?.stop();
+    }
+    stopAll() {
+        for (const packager of [...this.running.values()])
+            packager.stop();
+    }
+    get count() {
+        return this.running.size;
+    }
+}

package/dist/server.d.ts

@@ -11,6 +11,7 @@ import { SignIn } from "./oauth.ts";
 import { Owner } from "./owner.ts";
 import { Directory } from "./directory.ts";
 import { PartyLine } from "./partyline.ts";
+import { HlsPackagers } from "./hls.ts";
 import { Follows } from "./follows.ts";
 import { Favorites } from "./favorites.ts";
 import { Catalogs } from "./catalogs.ts";
@@ -422,6 +423,8 @@ export interface HandlerOptions {
     ffprobe?: string[];
     /** yt-dlp, which turns a pasted page into a media address. Null when there is none. */
     ytdlp?: string[] | null;
+    /** Channels as HLS, for Safari on a phone, which plays a live stream no other way. */
+    hls?: HlsPackagers;
     /** A Netscape cookies file for sites that want a signed-in browser, when there is one. */
     cookies?: string;
     /** Who is listening, for the admin view. */

package/dist/server.js

@@ -34,6 +34,7 @@ import { stateDir } from "./daemon.js";
 import { readSession } from "./session.js";
 import { Directory, ENDED_TTL_MS, parseAnnouncement } from "./directory.js";
 import { PartyLine, telnyxSms } from "./partyline.js";
+import { HlsPackagers, withKey } from "./hls.js";
 import { contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, playableLink, resolveLink, saveFormat, } from "./links.js";
 import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.js";
 import pg from "pg";
@@ -2441,8 +2442,52 @@ export function createHandler(engine, options) {
         if (path.startsWith("/api/channels/") && options.channels) {
             const channels = options.channels;
             const rest = path.slice("/api/channels/".length);
-            const [rawId, action] = rest.split("/");
+            const [rawId, action, file] = rest.split("/");
             const id = cleanId(rawId);
+            // The same channel as HLS: a playlist of short files, which is what
+            // Safari on an iPhone plays live -- it will not take the endless MP4
+            // below, and spun on it a few times before giving up. Packaged on
+            // demand, copying the fragments the browser would have got.
+            if (action === "hls" && request.method === "GET") {
+                if (!options.hls) {
+                    json(response, 503, { error: "this server cannot package HLS" });
+                    return;
+                }
+                if (!channels.has(id)) {
+                    json(response, 404, { error: "nothing is playing on that channel" });
+                    return;
+                }
+                if (file === "index.m3u8") {
+                    const playlist = await options.hls.playlist(id);
+                    if (playlist === null) {
+                        json(response, 503, { error: "that channel could not be packaged as HLS yet; try again in a moment" });
+                        return;
+                    }
+                    response.writeHead(200, {
+                        ...CORS,
+                        "content-type": "application/vnd.apple.mpegurl",
+                        "cache-control": "no-store",
+                    });
+                    // The key rides on every segment line: a browser drops the query
+                    // when it resolves a segment against the playlist.
+                    response.end(withKey(playlist, url.searchParams.get("k") ?? ""));
+                    return;
+                }
+                const segment = options.hls.segment(id, file ?? "");
+                if (segment === "") {
+                    json(response, 404, { error: "no such segment" });
+                    return;
+                }
+                watch(request, response, "stream", id);
+                response.writeHead(200, {
+                    ...CORS,
+                    "content-type": "video/mp2t",
+                    "cache-control": "no-store",
+                    "content-length": statSync(segment).size,
+                });
+                createReadStream(segment).pipe(response);
+                return;
+            }
             if (action === undefined && request.method === "GET") {
                 // Listening. The response is the fan-out target: whatever ffmpeg
                 // produces for this channel is written to it until one end goes away.
@@ -3474,6 +3519,13 @@ export async function serve(argv, version = "0.1.0") {
         onStart: (info) => console.log(`  ${info.name} is publishing to "${info.id}" (${info.format} over ${info.via}).`),
         onEnd: (info) => console.log(`  "${info.id}" stopped.`),
     });
+    // Channels as HLS, on demand, for Safari on a phone: one ffmpeg copying a
+    // channel's fragments into short files while somebody is asking for them.
+    const hls = new HlsPackagers({
+        ffmpeg: tools.ffmpeg,
+        listen: (id, listener) => channels.listen(id, listener),
+        onEvent: (message) => console.log(message),
+    });
     // The channels this server was carrying when it was last stopped, put back
     // on. A server is restarted to pick up a new version, which is often, and
     // every restart used to take CNN off the air until somebody noticed.
@@ -3825,6 +3877,7 @@ export async function serve(argv, version = "0.1.0") {
         // for the sites that will not talk to a datacenter without one.
         ytdlp: tools.ytdlp ?? null,
         cookies: cookiesFile(),
+        hls,
         ...(tls ? { tls } : {}),
         // Untagged, so a directory of five thousand files answers at once; the
         // tags follow through `tag` below.
@@ -4244,6 +4297,7 @@ export async function serve(argv, version = "0.1.0") {
     });
     const shutdown = () => {
         rtmp?.stop();
+        hls.stopAll();
         channels.stopAll();
         ingest?.stopRtmp();
         ingest?.close();

package/package.json

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

package/src/audio.ts

@@ -468,7 +468,11 @@ export function videoArgs(codecs: Codecs, capKbps = 0): string[] {
   const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
   return [
     "-c:v", keepVideo ? "copy" : "libx264",
-    ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),
+    // A keyframe every two seconds when encoding. A fragment starts on a
+    // keyframe, so this is how soon a joiner sees a picture -- and an HLS
+    // segment, which is cut on keyframes too, was ten seconds long on
+    // x264's default and made a phone wait thirty before it played.
+    ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p", "-g", "48", "-keyint_min", "48", "-sc_threshold", "0"]),
     "-c:a", keepAudio ? "copy" : "aac",
     ...(keepAudio ? [] : ["-b:a", "160k", "-ac", "2"]),
     "-f", "mp4",