nixamp 0.23.0 → 0.23.2

package/src/audio.ts

@@ -425,6 +425,14 @@ export interface Codecs {
    */
   width?: number;
   height?: number;
+  /**
+   * Whether a sleeve is embedded: the attached picture an MP3 or M4A of a
+   * podcast carries. Not a picture to play, but a picture to show -- on
+   * the link preview and the lock screen -- and `coverArtOf` reads it out.
+   */
+  cover?: boolean;
+  /** What the file says about itself in its tags, for naming a bare file. */
+  tags?: { title?: string; artist?: string; album?: string };
 }
 
 /**
@@ -449,7 +457,7 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
         // 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",
+        "-show_entries", "format=format_name,duration:format_tags=title,artist,album: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
@@ -475,9 +483,11 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
             codec_type?: string; codec_name?: string; width?: number; height?: number;
             disposition?: { attached_pic?: number };
           }[];
-          format?: { format_name?: string; duration?: string };
+          format?: { format_name?: string; duration?: string; tags?: Record<string, unknown> };
         };
         const streams = parsed.streams ?? [];
+        const cover = streams.some((s) => s.codec_type === "video" && s.disposition?.attached_pic === 1);
+        const tags = tagsOf(parsed.format?.tags);
         // 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);
@@ -489,6 +499,8 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
           duration: Number.isFinite(seconds) && seconds > 0 ? seconds : 0,
           ...(typeof picture?.width === "number" && picture.width > 0 ? { width: picture.width } : {}),
           ...(typeof picture?.height === "number" && picture.height > 0 ? { height: picture.height } : {}),
+          ...(cover ? { cover } : {}),
+          ...(tags ? { tags } : {}),
         });
       } catch {
         return done(empty);
@@ -497,6 +509,24 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
   });
 }
 
+/**
+ * The title, artist and album a file carries in its tags, however the
+ * container spells the keys (ID3 says TIT2 but ffprobe says title; MP4 and
+ * Matroska say Title). Absent when it carries none worth keeping.
+ */
+export function tagsOf(raw: Record<string, unknown> | undefined): Codecs["tags"] | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const lower: Record<string, string> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") lower[key.toLowerCase()] = value.replace(/[\u0000-\u001F\u007F]+/g, " ").trim().slice(0, 200);
+  }
+  const tags: NonNullable<Codecs["tags"]> = {};
+  if (lower["title"]) tags.title = lower["title"];
+  if (lower["artist"]) tags.artist = lower["artist"];
+  if (lower["album"]) tags.album = lower["album"];
+  return Object.keys(tags).length > 0 ? tags : undefined;
+}
+
 /**
  * Cover art is not a picture.
  *

package/src/channels.ts

@@ -72,7 +72,7 @@ export interface ChannelInfo {
   position?: number;
   live?: boolean;
   /** What the source turned out to hold, so a restart need not ask again. */
-  codecs?: { video: string; audio: string; container: string; duration?: number; width?: number; height?: number };
+  codecs?: { video: string; audio: string; container: string; duration?: number; width?: number; height?: number; cover?: boolean };
   /**
    * What the channel itself is producing, which is not always what its source
    * holds: an H.265 source is usually re-encoded to H.264 on the way out,
@@ -95,6 +95,15 @@ export interface ChannelInfo {
    * plain URL is read this way, and only when a policy asks for it.
    */
   teed?: boolean;
+  /**
+   * A picture of it from somewhere else: the thumbnail the site offered
+   * for a pasted link, the logo a catalog gave a channel. A channel with
+   * none may still have one of its own -- a sleeve in the file, a frame of
+   * the picture -- which /api/channels/:id/art reads out on demand.
+   */
+  art?: string;
+  /** A line about it for a preview: the show, the uploader, the first line of the notes. */
+  about?: string;
 }
 
 /** Where a pulled source is picked up from, and whether it can be at all. */
@@ -1201,7 +1210,7 @@ export interface RememberedChannel {
    * air as sound alone.
    */
   kind?: "audio" | "video";
-  codecs?: { video: string; audio: string; container: string; duration?: number; width?: number; height?: number };
+  codecs?: { video: string; audio: string; container: string; duration?: number; width?: number; height?: number; cover?: boolean };
   /** Where a film had got to, in seconds, so it picks up there. */
   position?: number;
   /** A live source has nowhere to pick up from. */
@@ -1211,6 +1220,9 @@ export interface RememberedChannel {
   /** For a list: every entry, and which was on, so it carries on from there. */
   playlist?: string[];
   playlistAt?: number;
+  /** Its picture and its line, as the site gave them, so a restart need not ask. */
+  art?: string;
+  about?: string;
 }
 
 const REMEMBERED = "channels.json";
@@ -1242,6 +1254,9 @@ export function rememberedChannels(dir: string, port: number): RememberedChannel
             // channel comes back at a size that cannot keep up.
             if (typeof c["width"] === "number" && Number.isFinite(c["width"])) kept.codecs.width = c["width"];
             if (typeof c["height"] === "number" && Number.isFinite(c["height"])) kept.codecs.height = c["height"];
+            // A sleeve in the file is a picture for the card, and knowing it
+            // is there saves reading the file again to find out.
+            if (c["cover"] === true) kept.codecs.cover = true;
           }
         }
         if (typeof one["position"] === "number" && Number.isFinite(one["position"]) && one["position"] > 0) kept.position = one["position"];
@@ -1252,6 +1267,8 @@ export function rememberedChannels(dir: string, port: number): RememberedChannel
           if (entries.length > 0) kept.playlist = entries;
           if (typeof one["playlistAt"] === "number" && Number.isInteger(one["playlistAt"]) && one["playlistAt"] >= 0) kept.playlistAt = one["playlistAt"];
         }
+        if (typeof one["art"] === "string" && /^https?:\/\//i.test(one["art"])) kept.art = one["art"].slice(0, 2048);
+        if (typeof one["about"] === "string" && one["about"] !== "") kept.about = one["about"].slice(0, 200);
         return kept;
       });
   } catch {
@@ -1279,6 +1296,8 @@ export function rememberedNow(channels: Channels): RememberedChannel[] {
         kept.playlist = one.playlist;
         kept.playlistAt = one.playlistAt ?? 0;
       }
+      if (one.art) kept.art = one.art;
+      if (one.about) kept.about = one.about;
       return kept;
     });
 }

package/src/directory.ts

@@ -79,6 +79,12 @@ export interface Listing {
    * about another on the same server.
    */
   channelCodes: Record<string, string>;
+  /**
+   * The same channels with what a preview needs: the id a join link names
+   * them by, a picture, a line. `channels` stays the list of names for
+   * the phone line and for anything reading an older listing.
+   */
+  lineup: LineupEntry[];
   /** Set by the directory from the request, never by the publisher. */
   updatedAt: number;
   /** When this stream first announced itself: the "started at" a caller hears. */
@@ -131,9 +137,27 @@ export interface Announcement {
   playing?: boolean;
   /** Names of the live channels on it. Absent from an older publisher. */
   channels?: string[];
+  /** Each of those with its id, picture and line. Absent from an older publisher. */
+  lineup?: LineupEntry[];
+}
+
+/**
+ * One live channel as a preview sees it. The picture is a web address the
+ * publisher vouches for -- its own art route, or the thumbnail a site gave
+ * it -- and a crawler fetches it, so it is only ever http(s).
+ */
+export interface LineupEntry {
+  id: string;
+  name: string;
+  kind: "audio" | "video";
+  art: string;
+  about: string;
 }
 
 const MAX_NAME = 60;
+const MAX_ID = 64;
+const MAX_ABOUT = 200;
+const MAX_ART = 2048;
 const MAX_TRACK = 120;
 /** How many channel names a listing carries. A multiview is four; eight is plenty. */
 const MAX_CHANNELS = 8;
@@ -206,6 +230,28 @@ export function parseAnnouncement(input: unknown): Announcement | null {
             .slice(0, MAX_CHANNELS),
         }
       : {}),
+    ...(Array.isArray(record["lineup"])
+      ? { lineup: (record["lineup"] as unknown[]).map(parseLineupEntry).filter((one): one is LineupEntry => one !== null).slice(0, MAX_CHANNELS) }
+      : {}),
+  };
+}
+
+/** One lineup entry as a publisher sent it, cleaned, or null when it is not one. */
+export function parseLineupEntry(input: unknown): LineupEntry | null {
+  if (typeof input !== "object" || input === null) return null;
+  const record = input as Record<string, unknown>;
+  const id = clean(record["id"], MAX_ID);
+  const name = clean(record["name"], MAX_NAME);
+  if (id === "" || name === "") return null;
+  const art = clean(record["art"], MAX_ART);
+  return {
+    id,
+    name,
+    kind: record["kind"] === "video" ? "video" : "audio",
+    // A picture is somewhere a crawler can go, or nothing: a data: URL is a
+    // page in a tag, and javascript: is a page in a tag that runs.
+    art: publishable(art) !== null ? art : "",
+    about: clean(record["about"], MAX_ABOUT),
   };
 }
 
@@ -304,6 +350,7 @@ export class Directory {
       // listing always meant, and no channels is the honest empty list.
       playing: announcement.playing ?? true,
       channels: announcement.channels ?? [],
+      lineup: announcement.lineup ?? [],
       channelCodes: this.codesFor(
         announcement.channels ?? [],
         // What each channel has been called before, on this listing: a

package/src/links.ts

@@ -51,6 +51,17 @@ export interface ResolvedLink {
   ext: string;
   /** The page it came from. */
   page: string;
+  /**
+   * A picture of it, when the site offered one: the video's thumbnail, the
+   * podcast's cover. This is what a link preview shows, and the lock screen
+   * while it plays. "" when there is none.
+   */
+  thumbnail: string;
+  /**
+   * A line about it for a preview: who put it up, and the first line of
+   * what they said about it. "" when the site said nothing.
+   */
+  about: 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
@@ -184,6 +195,8 @@ export async function resolvePlaylist(
     extractor: "playlist",
     ext: "",
     page: url,
+    thumbnail: "",
+    about: "",
     playlist: list.sources,
   };
 }
@@ -315,9 +328,58 @@ export function parseResolved(json: unknown, page: string): ResolvedLink | null
     extractor: typeof record["extractor"] === "string" ? record["extractor"] : "",
     ext: typeof record["ext"] === "string" && /^[a-z0-9]{1,5}$/i.test(record["ext"]) ? record["ext"].toLowerCase() : "",
     page,
+    thumbnail: thumbnailOf(record),
+    about: aboutOf(record),
   };
 }
 
+/** A web address a preview can fetch, or "". Only http(s): a data: URL is a page in a tag. */
+export function pictureUrl(value: unknown): string {
+  if (typeof value !== "string" || value.length > 2048) return "";
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "https:" || parsed.protocol === "http:" ? parsed.toString() : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * The picture yt-dlp found: `thumbnail` is its pick, and failing that the
+ * last of `thumbnails`, which it lists smallest first.
+ */
+function thumbnailOf(record: Record<string, unknown>): string {
+  const chosen = pictureUrl(record["thumbnail"]);
+  if (chosen !== "") return chosen;
+  const list = Array.isArray(record["thumbnails"]) ? (record["thumbnails"] as unknown[]) : [];
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    const one = list[index];
+    const url = one && typeof one === "object" ? pictureUrl((one as Record<string, unknown>)["url"]) : "";
+    if (url !== "") return url;
+  }
+  return "";
+}
+
+/** How much of a description a preview gets. A card is a line or two, not the notes. */
+export const ABOUT_MAX = 200;
+
+/** Who put it up, and the first line they wrote about it, as one line. */
+function aboutOf(record: Record<string, unknown>): string {
+  const who = ["uploader", "channel", "artist", "album"]
+    .map((field) => (typeof record[field] === "string" ? (record[field] as string).trim() : ""))
+    .find((one) => one !== "") ?? "";
+  const said = typeof record["description"] === "string"
+    ? record["description"].split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "") ?? ""
+    : "";
+  return oneLine([who, said].filter((one) => one !== "").join(" — "));
+}
+
+/** One line of plain text, no longer than a card wants. */
+export function oneLine(text: string): string {
+  const flat = text.replace(/[\u0000-\u001F\u007F]+/g, " ").replace(/\s+/g, " ").trim();
+  return flat.length > ABOUT_MAX ? `${flat.slice(0, ABOUT_MAX - 1).trimEnd()}…` : flat;
+}
+
 /** A bare file link, described without asking anybody. */
 export function directLink(url: string): ResolvedLink {
   return {
@@ -332,6 +394,8 @@ export function directLink(url: string): ResolvedLink {
     extractor: "direct",
     ext: (url.match(/\.([a-z0-9]{2,5})(\?.*)?$/i)?.[1] ?? "").toLowerCase(),
     page: url,
+    thumbnail: "",
+    about: "",
   };
 }
 

package/src/publish.ts

@@ -6,7 +6,7 @@
  * defaults to no, because "there was nobody to ask" is not consent.
  */
 import { createInterface } from "node:readline/promises";
-import { DEFAULT_DIRECTORY, HEARTBEAT_MS, type Listing } from "./directory.ts";
+import { DEFAULT_DIRECTORY, HEARTBEAT_MS, type LineupEntry, type Listing } from "./directory.ts";
 
 export interface PublishTarget {
   directory: string;
@@ -36,6 +36,8 @@ export interface PublishTarget {
   playing?: () => boolean;
   /** The live channels on this server, by name, for the listing to show. */
   channels?: () => string[];
+  /** The same channels with their id, picture and line, for a link preview. */
+  lineup?: () => LineupEntry[];
   /**
    * The account this stream belongs to, from `nixamp login`.
    *
@@ -122,6 +124,7 @@ export class Publisher {
           nowPlaying: this.target.nowPlaying(),
           ...(this.target.playing ? { playing: this.target.playing() } : {}),
           ...(this.target.channels ? { channels: this.target.channels() } : {}),
+          ...(this.target.lineup ? { lineup: this.target.lineup() } : {}),
         }),
       });
       if (!response.ok) {