nixamp 0.18.1 → 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/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;
@@ -497,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. */

package/dist/server.js

@@ -880,7 +880,9 @@ export async function pullChannel(channels, ffprobe, id, name, source, input = [
     if (assumed)
         console.log(`  "${id}": the source would not say what it holds; carrying it as ${kind}.`);
     // A film has a length and a place to go back to; a live source has neither.
-    const live = known.live ?? !((codecs.duration ?? 0) > 0);
+    // A list is a station: joined where it is, and never seeked.
+    const playlist = known.playlist && known.playlist.length > 0 ? known.playlist : null;
+    const live = playlist ? true : (known.live ?? !((codecs.duration ?? 0) > 0));
     const encode = kind === "video"
         ? [
             // Which streams from which input, when there are two: the picture
@@ -896,12 +898,14 @@ export async function pullChannel(channels, ffprobe, id, name, source, input = [
     // the timestamps a recording cut mid-stream does not carry. Ahead of the
     // caller's own input arguments, which are headers for the address itself.
     const opening = [...transportInputArgs(source, codecs.container), ...input];
-    const channel = channels.pull(id, name, source, encode, kind, true, undefined, opening, kind === "video" ? audio : "", { live, position: known.position ?? 0 }, 
+    const channel = channels.pull(id, name, source, encode, kind, true, undefined, opening, kind === "video" ? audio : "", { live, position: known.position ?? 0, ...(playlist ? { playlist } : {}) }, 
     // Known before the first dial: whether the source is a transport stream
     // decides whether it can be read here for a source-boundary relay.
     assumed ? undefined : codecs);
     if (channel && !assumed)
         channel.info.codecs = codecs;
+    if (channel && playlist && known.playlistAt !== undefined)
+        channel.info.playlistAt = known.playlistAt;
     // What comes out, as opposed to what went in. An H.265 source copied
     // through stays H.265; one re-encoded arrives as H.264, and a packager
     // told otherwise would cut fMP4 segments for a stream that did not need
@@ -943,11 +947,16 @@ function shownLink(channelId, link, channel) {
         channel: channelId,
         name: channel?.name ?? link.title,
         live,
-        video: link.video,
+        // Whether there is a picture is the channel's answer where there is one:
+        // a list is guessed at as video until its first entry has been probed,
+        // and a station of podcasts opened a video element for nothing.
+        video: channel?.kind ? channel.kind !== "audio" : link.video,
         duration: link.duration,
         extractor: link.extractor,
         // A live has no whole to keep; a bare file can be fetched by the browser itself.
         download: !live && link.extractor !== "direct",
+        // How many things a list holds, for the page to say.
+        entries: link.playlist?.length ?? 0,
     };
 }
 export function liveOnes(engine) {
@@ -2469,6 +2478,10 @@ export function createHandler(engine, options) {
                     // one nobody can dial is not worth showing.
                     code: state?.code ?? "",
                     url: state?.url ?? "",
+                    // Whether a link can go live here at all. The hosted directory
+                    // has no ffmpeg, and a page that offered to go live on it was
+                    // offering something that always failed.
+                    carries: options.carries !== false && Boolean(options.channels),
                 },
                 channels: (options.channels?.list() ?? []).map((one) => ({
                     id: one.id,
@@ -2485,6 +2498,8 @@ export function createHandler(engine, options) {
                     // How it has been going, for whoever may do something about it.
                     redials: one.redials ?? 0,
                     error: one.error ?? "",
+                    // For a list: how long it is, and which entry is on, from 0.
+                    ...(one.playlist ? { entries: one.playlist.length, entry: one.playlistAt ?? 0 } : {}),
                     // The member who put it on, when one did: theirs to take off.
                     startedBy: one.startedBy ?? "",
                 })),
@@ -2743,6 +2758,12 @@ export function createHandler(engine, options) {
                 json(response, 503, { error: "this server cannot carry channels" });
                 return;
             }
+            if (options.carries === false) {
+                json(response, 503, {
+                    error: `${options.serverName ?? "this server"} has no ffmpeg, so it cannot carry a link. Pick a server to go live on.`,
+                });
+                return;
+            }
             const channelId = linkChannelId(link);
             const known = links.get(link);
             // A member's is always a live: a decoder started on somebody else's
@@ -2816,7 +2837,7 @@ export function createHandler(engine, options) {
                     });
                     return;
                 }
-                const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media, inputArgsFor(resolved.headers), resolved.audio);
+                const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media, inputArgsFor(resolved.headers), resolved.audio, resolved.playlist ? { playlist: resolved.playlist } : {});
                 if (!started) {
                     json(response, 409, { error: "that link is already starting" });
                     return;
@@ -4257,6 +4278,7 @@ export async function serve(argv, version = "0.1.0") {
             ...(one.codecs ? { codecs: one.codecs } : {}),
             ...(one.position !== undefined ? { position: one.position } : {}),
             ...(one.live !== undefined ? { live: one.live } : {}),
+            ...(one.playlist ? { playlist: one.playlist, playlistAt: one.playlistAt ?? 0 } : {}),
         }).then((channel) => {
             if (!channel)
                 console.log(`  "${one.id}" is already on.`);
@@ -4269,7 +4291,8 @@ export async function serve(argv, version = "0.1.0") {
     let lastRemembered = "";
     setInterval(() => {
         const now = rememberedNow(channels);
-        if (!now.some((one) => one.position !== undefined))
+        // A list moves on without a position: which entry is on is the thing to keep.
+        if (!now.some((one) => one.position !== undefined || one.playlist))
             return;
         const text = JSON.stringify(now);
         if (text === lastRemembered)
@@ -4680,6 +4703,7 @@ export async function serve(argv, version = "0.1.0") {
         // A cookie jar beside the state, when the operator has put one there,
         // for the sites that will not talk to a datacenter without one.
         ytdlp: tools.ytdlp ?? null,
+        carries: tools.carries !== false,
         cookies: cookiesFile(),
         hls,
         compression,

package/package.json

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

package/src/audio.ts

@@ -31,6 +31,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;
 }
 
 function works(argv: string[], flag = "-version"): boolean {
@@ -112,6 +118,7 @@ export function detectTools(): Tools {
     ffprobe: ffprobe ?? ["ffprobe"],
     play,
     ytdlp,
+    carries: ffmpeg !== null,
   };
 }
 
@@ -439,7 +446,10 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
         ...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
@@ -461,14 +471,17 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
     child.on("close", () => {
       try {
         const parsed = JSON.parse(out) as {
-          streams?: { codec_type?: string; codec_name?: string; width?: number; height?: number }[];
+          streams?: {
+            codec_type?: string; codec_name?: string; width?: number; height?: number;
+            disposition?: { attached_pic?: number };
+          }[];
           format?: { format_name?: string; duration?: string };
         };
         const streams = parsed.streams ?? [];
         // 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 ?? "",
@@ -484,6 +497,22 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
   });
 }
 
+/**
+ * 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: { codec_name?: string; disposition?: { attached_pic?: number } }): boolean {
+  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;