nixamp 0.18.0 → 0.19.0

package/dist/audio.d.ts

@@ -15,6 +15,12 @@ export interface Tools {
     play: string[] | null;
     /** yt-dlp, which turns a pasted page into a media address; null when there is none. */
     ytdlp?: string[] | null;
+    /**
+     * Whether an ffmpeg was actually found, as opposed to guessed at. A server
+     * without one cannot carry a channel, and should say so before a link is
+     * resolved and probed and blamed for it.
+     */
+    carries?: boolean;
 }
 /**
  * Find the tools. A bare `ffmpeg` on PATH is tried first; mise shims are common
@@ -120,6 +126,12 @@ export interface Codecs {
  * the whole library came to be tagged with the process wedged solid.
  */
 export declare function codecsOf(tools: Tools, path: string, input?: string[]): Promise<Codecs>;
+export declare function isCoverArt(stream: {
+    codec_name?: string;
+    disposition?: {
+        attached_pic?: number;
+    };
+}): boolean;
 /** How much of a transport stream is read before deciding what is in it. */
 export declare const TRANSPORT_PROBE_BYTES: number;
 export declare const TRANSPORT_ANALYSE_US = 10000000;

package/dist/audio.js

@@ -91,6 +91,7 @@ export function detectTools() {
         ffprobe: ffprobe ?? ["ffprobe"],
         play,
         ytdlp,
+        carries: ffmpeg !== null,
     };
 }
 export function probe(tools, path) {
@@ -365,7 +366,10 @@ export async function codecsOf(tools, path, input = []) {
             ...rest,
             "-v", "quiet",
             "-print_format", "json",
-            "-show_entries", "format=format_name,duration:stream=codec_type,codec_name,width,height",
+            // The disposition too: an MP3 with its cover art in it carries that
+            // art as a video stream of one JPEG, and a probe that took it for a
+            // picture put a podcast on the air as a film with no frames.
+            "-show_entries", "format=format_name,duration:stream=codec_type,codec_name,width,height:stream_disposition=attached_pic",
             // A transport stream needs looking further into than a file with an
             // index does: there is no header listing the tracks, only packets, and
             // a 4K recording can carry a second of null padding and a long gap to
@@ -389,7 +393,7 @@ export async function codecsOf(tools, path, input = []) {
                 // ffprobe prints seconds as a string, and "N/A" for a stream with no
                 // end; both of those read as 0.
                 const seconds = Number(parsed.format?.duration ?? 0);
-                const picture = streams.find((s) => s.codec_type === "video");
+                const picture = streams.find((s) => s.codec_type === "video" && !isCoverArt(s));
                 return done({
                     video: picture?.codec_name ?? "",
                     audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
@@ -405,6 +409,22 @@ export async function codecsOf(tools, path, input = []) {
         });
     });
 }
+/**
+ * Cover art is not a picture.
+ *
+ * An MP3, FLAC or M4A with its sleeve embedded shows ffprobe a video stream:
+ * one JPEG or PNG, flagged as an attached picture. Carried as video it is a
+ * channel whose picture never gets a second frame -- ffmpeg writes nothing
+ * and the source is dialled again and again -- so a sleeve counts for
+ * nothing and the sound decides. A still-image codec with no such flag is
+ * the same thing from a container that does not flag it.
+ */
+const STILL_IMAGE = new Set(["png", "bmp", "gif", "tiff", "webp"]);
+export function isCoverArt(stream) {
+    if (stream.disposition?.attached_pic === 1)
+        return true;
+    return STILL_IMAGE.has((stream.codec_name ?? "").toLowerCase());
+}
 /** How much of a transport stream is read before deciding what is in it. */
 export const TRANSPORT_PROBE_BYTES = 20 * 1024 * 1024;
 export const TRANSPORT_ANALYSE_US = 10_000_000;

package/dist/channels.d.ts

@@ -33,6 +33,14 @@ export interface ChannelInfo {
     error?: string;
     /** How many times the source has been dialled again since it started. */
     redials?: number;
+    /**
+     * For a channel that plays a list: the entries, in order, and which one is
+     * on. When one ends the next is dialled at once, and the last is followed
+     * by the first: a station, not a file. A restart picks up at the entry
+     * that was on.
+     */
+    playlist?: string[];
+    playlistAt?: number;
     /**
      * For a pulled film: how far into it we are, in seconds, read off ffmpeg
      * as it goes. This is what a restart and a redial go back to. A live
@@ -78,6 +86,8 @@ export interface PullResume {
     live: boolean;
     /** Seconds into a film to start from. */
     position: number;
+    /** For a list of things rather than one: every entry, in order. */
+    playlist?: string[];
 }
 /**
  * A source read by us rather than by ffmpeg: what to tell ffmpeg it is,
@@ -187,6 +197,8 @@ export declare class Channel {
     private fragments;
     /** For a pulled channel: what to run, and how many times it has failed. */
     private redial;
+    /** For a channel playing a list: move to the next entry. Null when there is no list. */
+    private advance;
     private failures;
     private timer;
     /** Fires when a pulled source has said nothing for STALL. */
@@ -478,6 +490,9 @@ export interface RememberedChannel {
     live?: boolean;
     /** The member who put it on, so it is still theirs after a restart. */
     startedBy?: string;
+    /** For a list: every entry, and which was on, so it carries on from there. */
+    playlist?: string[];
+    playlistAt?: number;
 }
 export declare function rememberedChannels(dir: string, port: number): RememberedChannel[];
 /**

package/dist/channels.js

@@ -133,6 +133,8 @@ export class Channel {
     fragments = null;
     /** For a pulled channel: what to run, and how many times it has failed. */
     redial = null;
+    /** For a channel playing a list: move to the next entry. Null when there is no list. */
+    advance = null;
     failures = 0;
     timer = null;
     /** Fires when a pulled source has said nothing for STALL. */
@@ -220,20 +222,38 @@ export class Channel {
         if (this.info.kind === "video")
             this.fragments = new Fragments();
         const [command, ...prefix] = this.options.ffmpeg;
-        const remote = /^https?:\/\//i.test(source);
         this.info.live = resume.live;
         if (!resume.live)
             this.info.position = Math.max(0, resume.position);
-        // What every remote input is told: dial again when the CDN drops it, and
-        // give up on a socket that has gone quiet. Input options apply to the
-        // input that follows them, so a second input is told again.
-        const remoteArgs = remote
-            ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5", "-rw_timeout", String(stall * 1000)]
-            : [];
+        // A list plays entry by entry: the one that is on is what gets dialled,
+        // and an entry that ended is followed by the next, at once.
+        const list = resume.playlist && resume.playlist.length > 0 ? resume.playlist : null;
+        let at = 0;
+        if (list) {
+            this.info.playlist = list;
+            at = Math.min(Math.max(0, this.info.playlistAt ?? 0), list.length - 1);
+            this.info.playlistAt = at;
+        }
+        let current = list ? list[at] : source;
+        this.advance = list && list.length > 1
+            ? () => {
+                at = (at + 1) % list.length;
+                this.info.playlistAt = at;
+                current = list[at];
+                return true;
+            }
+            : null;
         const dial = () => {
             if (this.closing)
                 return;
             this.stderr = "";
+            const remote = /^https?:\/\//i.test(current);
+            // What every remote input is told: dial again when the CDN drops it, and
+            // give up on a socket that has gone quiet. Input options apply to the
+            // input that follows them, so a second input is told again.
+            const remoteArgs = remote
+                ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5", "-rw_timeout", String(stall * 1000)]
+                : [];
             // Where to pick a film up from: a little before where it was, since
             // the place was written down a moment ago and a moment of it twice is
             // better than a moment of it missing. A live source is joined as is,
@@ -291,7 +311,7 @@ export class Channel {
                         // and a CDN that got them from yt-dlp and not from us answers 403.
                         ...input,
                         ...seek,
-                        "-i", source,
+                        "-i", current,
                         // The sound, when the site keeps it apart from the picture: a
                         // second input, dialled the same way, that the encode maps in.
                         ...(audio ? [...remoteArgs, ...(paced ? ["-re"] : []), ...input, ...seek, "-i", audio] : []),
@@ -461,13 +481,22 @@ export class Channel {
             this.close();
             return;
         }
-        this.info.redials = (this.info.redials ?? 0) + 1;
+        // A list moves on. An entry that played to its end is not a source that
+        // dropped: the next is dialled now, and it is not a redial. One that
+        // gave nothing is skipped the same way, counted as the failure it was,
+        // so a list of dead links gives up rather than cycling for ever.
+        const moved = this.advance?.() ?? false;
+        const ended = moved && sent;
+        if (ended)
+            this.info.error = undefined;
+        else
+            this.info.redials = (this.info.redials ?? 0) + 1;
         this.startOver();
         const dial = this.redial;
         this.timer = setTimeout(() => {
             this.timer = null;
             dial();
-        }, REDIAL);
+        }, ended ? 0 : REDIAL);
         // A redial is not a reason to keep the process alive at exit.
         this.timer.unref?.();
     }
@@ -1032,6 +1061,13 @@ export function rememberedChannels(dir, port) {
                 kept.live = one["live"];
             if (typeof one["startedBy"] === "string" && one["startedBy"] !== "")
                 kept.startedBy = one["startedBy"];
+            if (Array.isArray(one["playlist"])) {
+                const entries = one["playlist"].filter((entry) => typeof entry === "string" && entry !== "");
+                if (entries.length > 0)
+                    kept.playlist = entries;
+                if (typeof one["playlistAt"] === "number" && Number.isInteger(one["playlistAt"]) && one["playlistAt"] >= 0)
+                    kept.playlistAt = one["playlistAt"];
+            }
             return kept;
         });
     }
@@ -1060,6 +1096,10 @@ export function rememberedNow(channels) {
             kept.position = Math.floor(one.position);
         if (one.startedBy)
             kept.startedBy = one.startedBy;
+        if (one.playlist && one.playlist.length > 0) {
+            kept.playlist = one.playlist;
+            kept.playlistAt = one.playlistAt ?? 0;
+        }
         return kept;
     });
 }

package/dist/links.d.ts

@@ -26,8 +26,40 @@ export interface ResolvedLink {
     ext: string;
     /** The page it came from. */
     page: string;
+    /**
+     * For a pasted .m3u: every entry in it, in order. The channel plays them
+     * one after another and starts over at the end, a station rather than a
+     * file; `media` is the first, for the probe that decides what it holds.
+     */
+    playlist?: string[];
 }
 export declare function isDirectMedia(url: string): boolean;
+export declare function isPlaylistLink(url: string): boolean;
+/** How much of a playlist is worth reading: a list, not a library dump. */
+export declare const PLAYLIST_MAX_BYTES = 2000000;
+export declare const PLAYLIST_MAX_ENTRIES = 1000;
+export declare const PLAYLIST_FETCH_TIMEOUT_MS = 15000;
+/**
+ * What a playlist's text holds: the entries, in order, resolved against
+ * where the list was fetched from. Some things called .m3u are HLS after
+ * all -- a segment list with #EXT-X- tags -- and those are one stream for
+ * ffmpeg to read as it is, not a list of streams.
+ */
+export declare function playlistFrom(text: string, base: string): {
+    hls: boolean;
+    sources: string[];
+};
+/**
+ * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
+ * here rather than by yt-dlp, which would take the first entry and stop, or
+ * by ffmpeg, which does not read a plain list at all.
+ */
+export declare function resolvePlaylist(url: string, options?: {
+    timeoutMs?: number;
+    fetcher?: typeof fetch;
+}): Promise<ResolvedLink | {
+    error: string;
+}>;
 /** A link somebody pasted, or "" when it is not one this can play. */
 export declare function playableLink(entered: unknown): string;
 /** A channel id for a link: stable, so two people pasting the same link share one decoder. */

package/dist/links.js

@@ -21,6 +21,7 @@
  */
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
+import { parseCatalog } from "./catalogs.js";
 /**
  * Formats that are a file, not a page.
  *
@@ -40,6 +41,85 @@ export function isDirectMedia(url) {
         return false;
     }
 }
+/**
+ * A plain m3u: a list of things to play, one per line, which is not a thing
+ * ffmpeg reads. The .m3u8 of HLS is a list of segments of one thing, which
+ * it does, and stays in DIRECT above.
+ */
+const PLAYLIST = /\.m3u(\?.*)?$/i;
+export function isPlaylistLink(url) {
+    try {
+        const parsed = new URL(url);
+        return PLAYLIST.test(parsed.pathname + parsed.search);
+    }
+    catch {
+        return false;
+    }
+}
+/** How much of a playlist is worth reading: a list, not a library dump. */
+export const PLAYLIST_MAX_BYTES = 2_000_000;
+export const PLAYLIST_MAX_ENTRIES = 1000;
+export const PLAYLIST_FETCH_TIMEOUT_MS = 15_000;
+/**
+ * What a playlist's text holds: the entries, in order, resolved against
+ * where the list was fetched from. Some things called .m3u are HLS after
+ * all -- a segment list with #EXT-X- tags -- and those are one stream for
+ * ffmpeg to read as it is, not a list of streams.
+ */
+export function playlistFrom(text, base) {
+    if (/^#EXT-X-/m.test(text))
+        return { hls: true, sources: [] };
+    const sources = parseCatalog(text, base)
+        .map((entry) => entry.source)
+        .filter((source) => /^(https?|rtmps?):\/\//i.test(source))
+        .slice(0, PLAYLIST_MAX_ENTRIES);
+    return { hls: false, sources };
+}
+/**
+ * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
+ * here rather than by yt-dlp, which would take the first entry and stop, or
+ * by ffmpeg, which does not read a plain list at all.
+ */
+export async function resolvePlaylist(url, options = {}) {
+    const get = options.fetcher ?? fetch;
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? PLAYLIST_FETCH_TIMEOUT_MS);
+    let text = "";
+    try {
+        const answer = await get(url, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: "follow" });
+        if (!answer.ok)
+            return { error: `that playlist could not be fetched (HTTP ${answer.status})` };
+        text = (await answer.text()).slice(0, PLAYLIST_MAX_BYTES);
+    }
+    catch (error) {
+        const why = abort.signal.aborted ? "took too long to answer" : (error.message || "could not be fetched");
+        return { error: `that playlist ${why}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const list = playlistFrom(text, url);
+    if (list.hls)
+        return directLink(url);
+    const [first] = list.sources;
+    if (!first)
+        return { error: "that playlist has nothing in it this can play" };
+    return {
+        title: fileNameOf(url).replace(/\.m3u$/i, "") || "Playlist",
+        media: first,
+        audio: "",
+        // A station: joined where it is, never seeked, and with no end to save.
+        live: true,
+        duration: 0,
+        // Whether there is a picture is the first entry's to say; ffprobe settles it.
+        video: true,
+        headers: {},
+        extractor: "playlist",
+        ext: "",
+        page: url,
+        playlist: list.sources,
+    };
+}
 /** A link somebody pasted, or "" when it is not one this can play. */
 export function playableLink(entered) {
     if (typeof entered !== "string")
@@ -277,6 +357,8 @@ export const RESOLVE_TIMEOUT_MS = 60_000;
 export async function resolveLink(ytdlp, url, options = {}) {
     if (isDirectMedia(url))
         return directLink(url);
+    if (isPlaylistLink(url))
+        return resolvePlaylist(url, { timeoutMs: options.timeoutMs });
     // Without yt-dlp, a link is taken as the media it may well be: an IPTV
     // feed has no extension and no page behind it, and ffprobe -- asked next,
     // before anything goes on the air -- tells a stream from a web page in a

package/dist/naming.d.ts

@@ -55,3 +55,17 @@ export declare function readCertFiles(stateDir: string, host: string): {
  * first label of its hostname, made safe for a subdomain.
  */
 export declare function labelFor(name: string, hostname: string): string;
+/**
+ * What to call a stream that was started on a path, for people.
+ *
+ * `nixamp serve ~/Music/live-sets_2024` used to be listed as the machine's
+ * hostname, which tells a stranger nothing. The last segment of the path is
+ * what the person who made the folder called it, so that is the title: the
+ * separators that a filesystem forces become spaces, a playlist loses its
+ * ending, and each lowercase word gets a capital. Words with a capital in
+ * them already are left alone, so "DJ" and "LoFi" stay as written, and a
+ * dash or dot between two digits stays too, so a date is still a date.
+ * Empty when the path has no segment worth saying, and the caller falls
+ * back to whatever it used before.
+ */
+export declare function humanizeSource(source: string): string;

package/dist/naming.js

@@ -148,3 +148,46 @@ export function labelFor(name, hostname) {
     }
     return "server";
 }
+/** File endings that name a playlist rather than a folder, dropped from a title. */
+const PLAYLIST_ENDING = /\.(m3u8?|pls|xspf|txt|json)$/i;
+/**
+ * What to call a stream that was started on a path, for people.
+ *
+ * `nixamp serve ~/Music/live-sets_2024` used to be listed as the machine's
+ * hostname, which tells a stranger nothing. The last segment of the path is
+ * what the person who made the folder called it, so that is the title: the
+ * separators that a filesystem forces become spaces, a playlist loses its
+ * ending, and each lowercase word gets a capital. Words with a capital in
+ * them already are left alone, so "DJ" and "LoFi" stay as written, and a
+ * dash or dot between two digits stays too, so a date is still a date.
+ * Empty when the path has no segment worth saying, and the caller falls
+ * back to whatever it used before.
+ */
+export function humanizeSource(source) {
+    const remote = /^[a-z][a-z0-9+.-]*:\/\//i.test(source);
+    let last = "";
+    try {
+        const path = remote ? new URL(source).pathname : source;
+        last = path.split("/").filter(Boolean).pop() ?? "";
+        if (remote)
+            last = decodeURIComponent(last);
+    }
+    catch {
+        return "";
+    }
+    if (last === "" || last === "~" || last === ".")
+        return "";
+    const words = last
+        .replace(PLAYLIST_ENDING, "")
+        .replace(/(?<!\d)[-_.+]+|[-_.+]+(?!\d)/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (words === "")
+        return "";
+    return words
+        .split(" ")
+        .map((word) => (word === word.toLowerCase() ? word.charAt(0).toUpperCase() + word.slice(1) : word))
+        .join(" ")
+        .slice(0, 60)
+        .trim();
+}

package/dist/server.d.ts

@@ -400,6 +400,9 @@ export interface KnownSource {
     codecs?: Codecs;
     position?: number;
     live?: boolean;
+    /** A list of entries to play in turn, and which one was on. */
+    playlist?: string[];
+    playlistAt?: number;
 }
 /** How many times a source that answers nothing is asked, and how far apart. */
 export declare const PROBE_TRIES = 3;
@@ -458,9 +461,29 @@ export declare function isSignInPath(path: string): boolean;
  *
  * Read from the page rather than hard-coded, because one NixAmp serves several
  * branded clients and each brings its own head. og:site_name first, then the
- * part of the title before the dash, then the hostname.
+ * part of the title before the dash or the colon ("nixamp: broadcast live
+ * radio..." is nixamp), then the hostname.
  */
 export declare function brandOf(shell: string, site: string): string;
+/**
+ * What a join link is for, named by something this server actually knows.
+ *
+ * A link preview reads the page before any script runs, so the shell has to
+ * say what is on the air. On the directory that is the listing the link
+ * points at, and the channel on it if one is asked for; on a server it is
+ * the server itself, or one of its channels. A name that only appears in the
+ * query is not used: a page that titled itself with whatever the address said
+ * would be a preview anyone could put words in.
+ */
+export declare function joinSubject(url: URL, options: Pick<HandlerOptions, "directory" | "channels" | "serverName">): {
+    title: string;
+    where: string;
+} | null;
+/** The shell, titled for what a join link opens. */
+export declare function joinDocument(shell: string, subject: {
+    title: string;
+    where: string;
+}, site: string): string;
 export interface HandlerOptions {
     web: string | null;
     media: boolean;
@@ -477,6 +500,12 @@ export interface HandlerOptions {
     ffmpeg?: string[];
     /** Where ffprobe is, for asking what is inside a file before re-encoding it. */
     ffprobe?: string[];
+    /**
+     * Whether this server can carry a channel at all: false where no ffmpeg
+     * was found, as on the hosted directory, which then says so instead of
+     * resolving a link, probing it, and blaming the site.
+     */
+    carries?: boolean;
     /** 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. */