nixamp 0.10.1 → 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/directory.d.ts

@@ -100,6 +100,12 @@ export interface Ended {
     startedAt: number;
     /** The last heartbeat we saw, which is as close to "ended" as we can know. */
     endedAt: number;
+    /**
+     * The codes its channels had, so a server that stops and comes back -- an
+     * update restarts the daemon, and the daemon withdraws its listing on the
+     * way down -- puts each channel back under the code people were given.
+     */
+    channelCodes?: Record<string, string>;
 }
 /** How long an ended stream is still worth telling a caller about. */
 export declare const ENDED_TTL_MS: number;

package/dist/directory.js

@@ -129,8 +129,14 @@ export class Directory {
      */
     seedEnded(items) {
         for (const item of items) {
-            if (!this.ended.has(item.id) && !this.items.has(item.id))
+            if (!this.ended.has(item.id) && !this.items.has(item.id)) {
                 this.ended.set(item.id, item);
+                // Its channels' codes are reserved too, so a server coming back after
+                // the directory restarted still finds them its own.
+                if (item.channelCodes && Object.keys(item.channelCodes).length > 0) {
+                    this.channelHistory.set(item.id, { ...(this.channelHistory.get(item.id) ?? {}), ...item.channelCodes });
+                }
+            }
         }
     }
     constructor(ttl = TTL_MS, now = Date.now, 
@@ -186,7 +192,11 @@ export class Directory {
             // channel that was gone for a heartbeat -- a server restarting puts
             // its channels back a moment after it announces -- comes back to the
             // code people were given, not a new one.
-            { ...(this.channelHistory.get(id) ?? {}), ...(existing?.channelCodes ?? {}) }, id),
+            {
+                ...(previously && "channelCodes" in previously ? previously.channelCodes ?? {} : {}),
+                ...(this.channelHistory.get(id) ?? {}),
+                ...(existing?.channelCodes ?? {}),
+            }, id),
             updatedAt: this.now(),
             // A stream that never stopped keeps its original start. One that did
             // starts again now, because that is what a caller is being told about.
@@ -204,7 +214,7 @@ export class Directory {
         if (item !== undefined)
             this.remember(item);
         this.items.delete(id);
-        this.channelHistory.delete(id);
+        // The channel history stays with the ended record, and goes when it goes.
     }
     list() {
         this.sweep();
@@ -322,6 +332,9 @@ export class Directory {
             nowPlaying: item.nowPlaying,
             startedAt: item.startedAt,
             endedAt: item.updatedAt,
+            // Every code its channels have had, not only the ones on at the end:
+            // a restart announces before its channels are back.
+            channelCodes: { ...(this.channelHistory.get(item.id) ?? {}), ...item.channelCodes },
         };
         this.ended.set(item.id, record);
         this.mirror?.save(record);
@@ -344,13 +357,13 @@ export class Directory {
             if (item.updatedAt < cutoff) {
                 this.remember(item);
                 this.items.delete(id);
-                this.channelHistory.delete(id);
             }
         }
         const forget = this.now() - ENDED_TTL_MS;
         for (const [id, item] of this.ended) {
             if (item.endedAt < forget) {
                 this.ended.delete(id);
+                this.channelHistory.delete(id);
                 this.mirror?.drop(id);
             }
         }

package/dist/durable.d.ts

@@ -34,6 +34,8 @@ export interface StoredEnded {
     nowPlaying: string;
     startedAt: number;
     endedAt: number;
+    /** Each channel's phone code, by name, so a server coming back keeps them. */
+    channelCodes?: Record<string, string>;
 }
 export declare class Durable {
     private readonly db;

package/dist/durable.js

@@ -9,6 +9,7 @@ const SCHEMA = `
     started_at   BIGINT NOT NULL,
     ended_at     BIGINT NOT NULL
   );
+  ALTER TABLE ended_streams ADD COLUMN IF NOT EXISTS channel_codes JSONB NOT NULL DEFAULT '{}'::jsonb;
   CREATE INDEX IF NOT EXISTS ended_streams_code ON ended_streams (code);
 
   CREATE TABLE IF NOT EXISTS stream_reminders (
@@ -18,6 +19,26 @@ const SCHEMA = `
     PRIMARY KEY (code, phone)
   );
 `;
+/** A JSONB column, as pg hands it back: an object already, or a string on an odd driver. */
+function codesFrom(value) {
+    let parsed = value;
+    if (typeof value === "string") {
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            return {};
+        }
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const codes = {};
+    for (const [name, code] of Object.entries(parsed)) {
+        if (typeof code === "string" && /^\d{6}$/.test(code))
+            codes[name] = code;
+    }
+    return codes;
+}
 export class Durable {
     db;
     onEvent;
@@ -48,8 +69,8 @@ export class Durable {
     }
     async saveEnded(stream) {
         await this.quietly("an ended stream", () => this.db.query(`INSERT INTO ended_streams
-           (id, code, name, owner_id, url, now_playing, started_at, ended_at)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+           (id, code, name, owner_id, url, now_playing, started_at, ended_at, channel_codes)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb)
          ON CONFLICT (id) DO UPDATE
            SET code = EXCLUDED.code,
                name = EXCLUDED.name,
@@ -57,7 +78,8 @@ export class Durable {
                url = EXCLUDED.url,
                now_playing = EXCLUDED.now_playing,
                started_at = EXCLUDED.started_at,
-               ended_at = EXCLUDED.ended_at`, [
+               ended_at = EXCLUDED.ended_at,
+               channel_codes = EXCLUDED.channel_codes`, [
             stream.id,
             stream.code,
             stream.name,
@@ -66,6 +88,7 @@ export class Durable {
             stream.nowPlaying,
             stream.startedAt,
             stream.endedAt,
+            JSON.stringify(stream.channelCodes ?? {}),
         ]));
     }
     /** A stream that came back, or one old enough to forget. */
@@ -88,6 +111,7 @@ export class Durable {
                 // nothing like a number.
                 startedAt: Number(r["started_at"] ?? 0),
                 endedAt: Number(r["ended_at"] ?? 0),
+                channelCodes: codesFrom(r["channel_codes"]),
             }));
         }
         catch (error) {

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.1",
+  "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",