@gentbajko/slopify 2.3.1 → 2.5.0

package/dist/slices/video/edit-settings.js

@@ -0,0 +1,191 @@
+// How the Video stage edits the slideshow beyond seconds per image, zoom and motion: where the
+// cuts fall, how one shot hands over to the next, the Look (vignette, grain, colour, an
+// atmosphere overlay and chapter cards), and which images come to life as short clips.
+// Browser-safe: Play, Edit project, the review summary and the change list read these names,
+// labels and limits too.
+//
+// A project saved before this existed has no settings at all, and absent reads as
+// `legacyVideoEdit`: cuts every N seconds, hard cuts, no Look, nothing animated. That is what
+// every video was, and the render recipe leaves every one of those values out of its
+// fingerprint, so no finished video turns outdated. A new project starts from
+// `defaultVideoEdit`, which follows the narration.
+export const cutModes = ["interval", "narration"];
+export const transitionKinds = ["cut", "crossfade", "fadeblack", "slide", "wipe"];
+export const lookLevels = ["off", "subtle", "strong"];
+export const colorGrades = ["none", "warm", "cold", "desaturated", "sepia"];
+// Drawn procedurally by ffmpeg's own filters (`look.ts`); no third-party footage.
+export const atmospheres = ["none", "embers", "dust", "fog"];
+export const animateModes = ["off", "chapters", "every"];
+export const legacyVideoEdit = {
+    cuts: "interval",
+    transition: "cut",
+    transitionSeconds: 0.6,
+    vignette: "off",
+    grain: "off",
+    grade: "none",
+    atmosphere: "none",
+    chapterCards: false,
+    animate: "off",
+    animateEvery: 3,
+    animateModel: "",
+};
+// What a new project starts with: the owner's pick is to follow the narration.
+export const defaultVideoEdit = { ...legacyVideoEdit, cuts: "narration" };
+// ceiling: under 0.2 s a transition is a flash rather than a move; over 2 s it eats a short
+// shot. The steps are the ones Play and Edit project offer.
+export const transitionSecondsMin = 0.2;
+export const transitionSecondsMax = 2;
+export const transitionSecondsSteps = [0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.5, 2];
+export const animateEveryMin = 2;
+export const animateEveryMax = 10;
+// Image-to-video models make 5-second clips at their cheapest; a longer shot slows or loops
+// the clip (`video/clip-timing.ts`).
+export const animatedClipSeconds = 5;
+// What an image is animated with: keep the picture, move a little. Image-to-video models
+// invent the most when told the least.
+export const animatePrompt = "Subtle cinematic motion: a slow, steady camera push-in with gentle ambient movement in the scene. Keep the composition, colours, lighting and style of the image exactly. No new objects, no text, no cuts.";
+// A cut never lands closer than this share of Seconds per image to the one before, unless a
+// chapter starts there.
+export const cutFloorShare = 0.4;
+// How long a chapter card stays on screen, fades included.
+export const chapterCardSeconds = 2.5;
+export const cutModeLabels = {
+    interval: "Every N seconds",
+    narration: "Follow the narration",
+};
+export const transitionLabels = {
+    cut: "Cut",
+    crossfade: "Crossfade",
+    fadeblack: "Fade through black",
+    slide: "Slide",
+    wipe: "Wipe",
+};
+export const lookLevelLabels = {
+    off: "Off",
+    subtle: "Subtle",
+    strong: "Strong",
+};
+export const colorGradeLabels = {
+    none: "None",
+    warm: "Warm fantasy",
+    cold: "Cold",
+    desaturated: "Desaturated",
+    sepia: "Sepia",
+};
+export const atmosphereLabels = {
+    none: "None",
+    embers: "Embers",
+    dust: "Dust",
+    fog: "Fog",
+};
+export const animateModeLabels = {
+    off: "Off",
+    chapters: "Chapter openers",
+    every: "Every Nth image",
+};
+// The settings a project renders with: its own, or today's behaviour when it has none.
+export function videoEditOf(config) {
+    return config.videoEdit ?? legacyVideoEdit;
+}
+// Following the narration needs narration to follow and a video to cut; otherwise the video
+// falls back to Every N seconds, which is also what its fingerprint says.
+export function usesNarrationCuts(config) {
+    return (videoEditOf(config).cuts === "narration" &&
+        config.sources.audio !== "off" &&
+        config.sources.video === "generate");
+}
+// Chapter cards are placed from the narration's word timing, so they need narration too.
+export function usesChapterCards(config) {
+    return (videoEditOf(config).chapterCards &&
+        config.sources.audio !== "off" &&
+        config.sources.video === "generate");
+}
+// "Chapter openers" needs chapters, which come from the narration's word timing.
+export function usesAnimation(config) {
+    const edit = videoEditOf(config);
+    return (edit.animate !== "off" &&
+        config.sources.video === "generate" &&
+        (edit.animate === "every" || config.sources.audio !== "off"));
+}
+// Whether the render needs the word timing: to cut on sentences, to place chapter cards, or to
+// know which images open a chapter.
+export function editNeedsTiming(config) {
+    return (usesNarrationCuts(config) ||
+        usesChapterCards(config) ||
+        (usesAnimation(config) && videoEditOf(config).animate === "chapters"));
+}
+// The words a problem with one of the settings is said in; shared by admission, Play's draft
+// conversion and Edit project.
+export function videoEditProblems(config) {
+    const edit = config.videoEdit;
+    if (edit === undefined || config.sources.video !== "generate")
+        return [];
+    const problems = [];
+    if (edit.transition !== "cut" &&
+        !(Number.isFinite(edit.transitionSeconds) &&
+            edit.transitionSeconds >= transitionSecondsMin &&
+            edit.transitionSeconds <= transitionSecondsMax))
+        problems.push({
+            field: "transitionSeconds",
+            message: `Choose a transition length between ${String(transitionSecondsMin)} and ${String(transitionSecondsMax)} seconds.`,
+        });
+    if (edit.chapterCards && config.sources.audio === "off")
+        problems.push({
+            field: "chapterCards",
+            message: "Chapter cards are placed from the narration. Turn narration on, or turn chapter cards off.",
+        });
+    if (edit.animate === "chapters" && config.sources.audio === "off")
+        problems.push({
+            field: "animate",
+            message: "Chapter openers are found from the narration. Turn narration on, or choose Every Nth image.",
+        });
+    if (edit.animate === "every" &&
+        !(Number.isInteger(edit.animateEvery) &&
+            edit.animateEvery >= animateEveryMin &&
+            edit.animateEvery <= animateEveryMax))
+        problems.push({
+            field: "animateEvery",
+            message: `Choose every 2nd to every ${String(animateEveryMax)}th image.`,
+        });
+    if (edit.animate !== "off" && edit.animateModel.trim() === "")
+        problems.push({
+            field: "animateModel",
+            message: "Choose an image-to-video model to animate images with, or turn Animate images off.",
+        });
+    return problems;
+}
+// The settings in words, one row each, as the change list and the review summary show them.
+export function videoEditRows(edit) {
+    const nth = (n) => (n === 2 ? "2nd" : n === 3 ? "3rd" : `${String(n)}th`);
+    return [
+        ["Cuts", cutModeLabels[edit.cuts]],
+        [
+            "Transition",
+            edit.transition === "cut"
+                ? transitionLabels.cut
+                : `${transitionLabels[edit.transition]} · ${String(edit.transitionSeconds)} s`,
+        ],
+        ["Vignette", lookLevelLabels[edit.vignette]],
+        ["Film grain", lookLevelLabels[edit.grain]],
+        ["Colour grade", colorGradeLabels[edit.grade]],
+        ["Atmosphere", atmosphereLabels[edit.atmosphere]],
+        ["Chapter cards", edit.chapterCards ? "On" : "Off"],
+        [
+            "Animate images",
+            edit.animate === "off"
+                ? animateModeLabels.off
+                : `${edit.animate === "every" ? `Every ${nth(edit.animateEvery)} image` : animateModeLabels.chapters}${edit.animateModel.trim() === "" ? "" : ` · ${edit.animateModel}`}`,
+        ],
+    ];
+}
+// Which images of the slideshow order (0-based) are animated: every Nth from the first, or
+// the ones that open a chapter. `chapterImages` is the image index each chapter opens on.
+export function animatedImageIndexes(edit, imageCount, chapterImages = []) {
+    if (edit.animate === "off" || imageCount <= 0)
+        return [];
+    if (edit.animate === "every") {
+        const every = Math.max(1, Math.round(edit.animateEvery));
+        return Array.from({ length: imageCount }, (_value, at) => at).filter((at) => at % every === 0);
+    }
+    return [...new Set(chapterImages.filter((at) => at >= 0 && at < imageCount))].toSorted((left, right) => left - right);
+}

package/dist/slices/video/ffmpeg.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { isAbsolute, resolve as resolvePath } from "node:path";
+import { gradeFilter, lookChain, lookEncoding, placed } from "./look.js";
 import { decimal, zoomRange } from "./plan.js";
+import { segments, transitionHalves } from "./transitions.js";
 // Hand-rolled per the standards: the filtergraph is the load-bearing part of this slice
 // and a wrapper would hide it. Every value goes into an argument array, never a shell
 // string, so a title or a filename cannot become a command.
@@ -33,49 +35,173 @@ export function resolveFfmpeg(env, bundled) {
 export function slideshowClips(edit) {
     const clips = [];
     const named = new Map();
-    const order = edit.shots.map((shot) => {
-        // The motion is plain data built in a fixed key order, so equal motions stringify
-        // alike.
-        const key = JSON.stringify([shot.source, shot.motion, shot.frames]);
+    const order = segments(edit.shots).map((segment) => {
+        const key = clipKey(edit, segment);
         let name = named.get(key);
         if (name === undefined) {
             name = `c${clips.length + 1}.mp4`;
             named.set(key, name);
-            clips.push({ name, shot });
+            const shot = edit.shots[segment.kind === "shot" ? segment.shot : segment.to];
+            if (shot === undefined)
+                throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use Re-run section on Video; if it happens again, use Download diagnostics in Settings and report it.");
+            clips.push({ name, segment, shot, frames: segment.count });
         }
         return name;
     });
     return { clips, order };
 }
+// What makes two clips the same encode. The motion is plain data built in a fixed key order,
+// so equal motions stringify alike. A whole shot keeps the key it always had, so an edit
+// list without transitions or a Look dedupes exactly as before.
+function clipKey(edit, segment) {
+    const at = placed(edit, segment.start, segment.count) ? segment.start : null;
+    if (segment.kind === "transition") {
+        const from = edit.shots[segment.from];
+        const to = edit.shots[segment.to];
+        return JSON.stringify([
+            "transition",
+            from?.source,
+            from?.motion,
+            from?.frames,
+            to?.source,
+            to?.motion,
+            to?.frames,
+            to?.transition,
+            at,
+        ]);
+    }
+    const shot = edit.shots[segment.shot];
+    const whole = segment.from === 0 && segment.count === shot?.frames;
+    return JSON.stringify(whole && at === null
+        ? [shot?.source, shot?.motion, shot?.frames]
+        : [shot?.source, shot?.motion, shot?.frames, segment.from, segment.count, at]);
+}
 // Clips that are joined by copying get the final encode's settings. Clips that will be
 // decoded again under burned-in captions are kept closer to the source, so the second
 // encode is not a visible second generation.
 const intermediateCrf = "16";
+// A whole shot as one clip.
 export function clipArgs(frame, shot, output, intermediate = false) {
-    const move = zoompan(shot.motion, shot.frames);
-    // A still that does not move has no sub-pixel steps to smooth, so it is not prescaled.
-    const factor = move === undefined ? 1 : prescale;
-    const wide = frame.width * factor;
-    const tall = frame.height * factor;
+    return segmentArgs({ ...frame, shots: [shot] }, { kind: "shot", shot: 0, from: 0, count: shot.frames, start: 0 }, output, intermediate);
+}
+// One clip of the slideshow: part of a shot, or a transition between two, with the Look.
+export function segmentArgs(edit, segment, output, intermediate = false, 
+// The clip's own chapter-card script, beside it in the working folder (`cards.ts`).
+cardsFile = "cards.ass") {
+    const inputs = [];
+    const chains = [];
+    const picture = (shot, from, label) => {
+        if (shot === undefined)
+            throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use Re-run section on Video; if it happens again, use Download diagnostics in Settings and report it.");
+        const at = inputs.filter((one) => one === "-i").length;
+        const built = pictureChain(edit, shot, from, segment.count, at, label, gradeFilter(edit.look));
+        inputs.push(...built.inputs);
+        chains.push(built.chain);
+    };
+    const look = lookChain(edit, segment.start, segment.count, "[p]", "[v]", cardsFile);
+    const picked = look === undefined ? "[v]" : "[p]";
+    if (segment.kind === "shot")
+        picture(edit.shots[segment.shot], segment.from, picked);
+    else {
+        const before = edit.shots[segment.from];
+        const after = edit.shots[segment.to];
+        const halves = transitionHalves(segment.count);
+        picture(before, (before?.frames ?? 0) - halves.tail, "[ta]");
+        picture(after, -halves.tail, "[tb]");
+        const style = after?.transition?.kind ?? "crossfade";
+        chains.push(`[ta][tb]xfade=transition=${xfadeNames[style]}:duration=${seconds6(segment.count / edit.fps)}:offset=0${picked}`);
+    }
+    if (look !== undefined)
+        chains.push(look);
     return [
         ...progressArgs,
-        "-i",
-        shot.source.path,
+        ...inputs,
         "-filter_complex",
-        `[0:v]trim=end_frame=1,setpts=PTS-STARTPTS,` +
-            // Cover the frame and centre-crop, never letterbox.
-            `scale=${wide}:${tall}:force_original_aspect_ratio=increase,crop=${wide}:${tall},` +
-            `zoompan=z='${move?.z ?? "1"}':d=${shot.frames}:` +
-            `x='${move?.x ?? centredX}':y='${move?.y ?? centredY}':` +
-            `s=${frame.width}x${frame.height}:fps=${frame.fps},setsar=1[v]`,
+        chains.join(";"),
         "-map",
         "[v]",
+        // The clip is exactly its frames, whatever a filter's rounding of seconds would give.
+        ...(segment.kind === "shot" && segment.from === 0 && look === undefined
+            ? []
+            : ["-frames:v", String(segment.count)]),
         ...videoCodec,
+        ...lookEncoding(edit.look),
         ...(intermediate ? ["-crf", intermediateCrf] : []),
         "-an",
         output,
     ];
 }
+const xfadeNames = {
+    crossfade: "fade",
+    fadeblack: "fadeblack",
+    slide: "slideleft",
+    wipe: "wipeleft",
+};
+// The picture of `count` frames of `shot` from its own frame `from`, into `label`. A frame
+// before the shot's first shows its first, and one past its last shows its last (a still's
+// motion holds) or plays on (a clip keeps running), which is what a transition overlapping
+// the cut shows.
+function pictureChain(frame, shot, from, count, input, label, grade) {
+    const source = shot.source;
+    if (source.kind === "video") {
+        const { width, height, fps } = frame;
+        const pad = Math.max(0, -from);
+        const first = from + pad;
+        return {
+            // Looped for as long as the shot needs; trim ends the stream.
+            inputs: ["-stream_loop", "-1", "-i", source.path],
+            chain: `[${String(input)}:v]setpts=(PTS-STARTPTS)*${slowdown(source.seconds, shot.frames / fps)},` +
+                `fps=${String(fps)},` +
+                `scale=${String(width)}:${String(height)}:force_original_aspect_ratio=increase,` +
+                `crop=${String(width)}:${String(height)},setsar=1,` +
+                (grade === undefined ? "" : `${grade},`) +
+                (pad > 0 ? `tpad=start=${String(pad)}:start_mode=clone,` : "") +
+                `trim=start_frame=${String(first)}:end_frame=${String(first + count)},` +
+                // Padding and trimming drop the declared rate, which a transition needs to match.
+                `setpts=PTS-STARTPTS,fps=${String(fps)},format=yuv420p${label}`,
+        };
+    }
+    const move = zoompan(shot.motion, shot.frames, frameExpression(from, count, shot.frames));
+    // A still that does not move has no sub-pixel steps to smooth, so it is not prescaled.
+    const factor = move === undefined ? 1 : prescale;
+    const wide = frame.width * factor;
+    const tall = frame.height * factor;
+    // Clips that meet in a transition are brought to one pixel format first, since xfade
+    // refuses to blend two that differ; a plain shot is left as it always was.
+    const plain = from === 0 && count === shot.frames;
+    return {
+        inputs: ["-i", source.path],
+        chain: `[${String(input)}:v]trim=end_frame=1,setpts=PTS-STARTPTS,` +
+            // The grade is applied here, to the one still frame, rather than to every frame after.
+            (grade === undefined ? "" : `${grade},`) +
+            // Cover the frame and centre-crop, never letterbox.
+            `scale=${wide}:${tall}:force_original_aspect_ratio=increase,crop=${wide}:${tall},` +
+            `zoompan=z='${move?.z ?? "1"}':d=${count}:` +
+            `x='${move?.x ?? centredX}':y='${move?.y ?? centredY}':` +
+            `s=${frame.width}x${frame.height}:fps=${frame.fps},setsar=1${plain ? "" : ",format=yuv420p"}${label}`,
+    };
+}
+// ceiling: a clip shorter than its shot is slowed to at most half speed, which still reads
+// as natural motion; past that it loops.
+const slowestSpeed = 2;
+// How much a clip of `clip` seconds is stretched to fill a shot of `shot` seconds, as exact
+// decimal text: 1 when it is long enough.
+export function slowdown(clip, shot) {
+    if (!(clip > 0) || shot <= clip)
+        return "1";
+    return decimal(Math.round(Math.min(slowestSpeed, shot / clip) * 1000));
+}
+// zoompan's `on` counts the clip's own frames from 0; a clip that starts `from` frames into
+// its shot adds that, and one that reaches before or past the shot holds at its ends.
+function frameExpression(from, count, frames) {
+    const shifted = from === 0 ? "on" : `(on${from > 0 ? "+" : "-"}${String(Math.abs(from))})`;
+    return from < 0 || from + count > frames
+        ? `clip(${shifted},0,${String(Math.max(0, frames - 1))})`
+        : shifted;
+}
+function seconds6(value) {
+    return value.toFixed(6);
+}
 // The concat demuxer's own format. Names are resolved beside the list and are this
 // module's `cN.mp4`, so nothing in them needs quoting.
 export function concatList(order) {
@@ -110,7 +236,7 @@ export function joinArgs(edit, output, list, burnSubtitles = false) {
         "-map",
         burnSubtitles ? "[v]" : "0:v",
         ...(edit.audio.length > 0 ? ["-map", "[a]"] : []),
-        ...(burnSubtitles ? videoCodec : ["-c:v", "copy"]),
+        ...(burnSubtitles ? [...videoCodec, ...lookEncoding(edit.look)] : ["-c:v", "copy"]),
         ...(edit.audio.length > 0 ? ["-c:a", "aac"] : ["-an"]),
         "-movflags",
         "+faststart",
@@ -132,10 +258,10 @@ const videoCodec = ["-c:v", "libx264", "-pix_fmt", "yuv420p"];
 const centredX = "iw/2-(iw/zoom/2)";
 const centredY = "ih/2-(ih/zoom/2)";
 // zoompan's expressions for a motion, or undefined for one that does not move. `on` is
-// zoompan's output frame counter, 0 to d-1, and a one-frame shot has no span to divide
-// by, so it holds where it starts. `zoom` in x and y is the current zoom, so iw-iw/zoom
-// is the room the crop window has to travel in.
-function zoompan(motion, frames) {
+// zoompan's output frame counter, 0 to d-1 (`at` shifts it for part of a shot), and a
+// one-frame shot has no span to divide by, so it holds where it starts. `zoom` in x and y is
+// the current zoom, so iw-iw/zoom is the room the crop window has to travel in.
+function zoompan(motion, frames, at = "on") {
     if (motion.kind === "still")
         return undefined;
     const range = zoomRange(motion.percent);
@@ -147,27 +273,27 @@ function zoompan(motion, frames) {
         const z = motion.direction === "in"
             ? span < 1
                 ? range.from
-                : `${range.from}+${range.by}*on/${span}`
+                : `${range.from}+${range.by}*${at}/${span}`
             : span < 1
                 ? range.to
-                : `${range.to}-${range.by}*on/${span}`;
+                : `${range.to}-${range.by}*${at}/${span}`;
         return { z, x: centredX, y: centredY };
     }
     return {
         z: range.to,
-        x: `(iw-iw/zoom)*(${travel(motion.from.x, motion.to.x, span)})`,
-        y: `(ih-ih/zoom)*(${travel(motion.from.y, motion.to.y, span)})`,
+        x: `(iw-iw/zoom)*(${travel(motion.from.x, motion.to.x, span, at)})`,
+        y: `(ih-ih/zoom)*(${travel(motion.from.y, motion.to.y, span, at)})`,
     };
 }
 // A share of the room from `from` to `to`, linear over the shot. Built in whole
 // thousandths as decimal text, like the zoom, so 1 - 0.5 reads 0.5 and never
 // 0.49999999999999994.
-function travel(from, to, span) {
+function travel(from, to, span, at) {
     const start = Math.round(from * 1000);
     const by = Math.round(to * 1000) - start;
     if (span < 1 || by === 0)
         return decimal(start);
-    return `${decimal(start)}${by > 0 ? "+" : "-"}${decimal(Math.abs(by))}*on/${span}`;
+    return `${decimal(start)}${by > 0 ? "+" : "-"}${decimal(Math.abs(by))}*${at}/${span}`;
 }
 function seconds(value) {
     return value.toFixed(3);

package/dist/slices/video/look.js

@@ -0,0 +1,164 @@
+// The Look: filters appended to each clip's picture before it is encoded, so they cost one
+// pass over frames that are being made anyway and the render stays clip by clip. Everything
+// is ffmpeg's own filters with fixed numbers: no footage, no LUT files, and the same project
+// renders the same frames every time.
+//
+// The colour grade is applied to each source before its picture is built (`gradeFilter`):
+// once on a still, before zoompan turns it into frames, rather than on every frame. So the
+// overlay and the vignette sit on graded colour. Order matters for the rest: the atmosphere
+// first; then the vignette darkens both; the chapter card is drawn on top of that
+// so its text stays clean; the grain last, over everything, as film grain is.
+// ceiling: the owner's eye on test renders. Subtle darkens the corners a little, strong
+// makes a clear frame of shadow.
+const vignetteAngle = {
+    subtle: "0.45",
+    strong: "0.75",
+};
+// Temporal noise on brightness only, so the grain moves like film and never tints.
+const grainStrength = {
+    subtle: 8,
+    strong: 16,
+};
+// The encoder settings a Look asks for: x264 smooths fine noise away at its default tuning,
+// so grain is encoded with its grain tuning. Every clip of one render has the same Look, so
+// the clips still join by copying.
+export function lookEncoding(look) {
+    return look !== undefined && look.grain !== "off" ? ["-tune", "grain"] : [];
+}
+const grades = {
+    // Golden highlights, a touch of amber in the mids, cooler shadows kept for depth.
+    warm: "colorbalance=rs=0.02:bs=0.04:rm=0.08:gm=0.02:bm=-0.07:rh=0.07:gh=0.03:bh=-0.08," +
+        "eq=saturation=1.12:contrast=1.04",
+    // Blue-green shadows and mids, highlights barely touched.
+    cold: "colorbalance=rs=-0.06:bs=0.08:rm=-0.05:gm=0.01:bm=0.06:rh=-0.02:bh=0.03,eq=saturation=0.9",
+    desaturated: "eq=saturation=0.55:contrast=1.06",
+    // The classic sepia matrix.
+    sepia: "colorchannelmixer=rr=0.393:rg=0.769:rb=0.189:gr=0.349:gg=0.686:gb=0.168:br=0.272:bg=0.534:bb=0.131",
+};
+// The grade as a filter for a picture's source, or undefined for none: a still is graded once,
+// a clip frame by frame.
+export function gradeFilter(look) {
+    return look === undefined || look.grade === "none" ? undefined : grades[look.grade];
+}
+export function hasLook(look) {
+    return (look !== undefined &&
+        (look.vignette !== "off" ||
+            look.grain !== "off" ||
+            look.grade !== "none" ||
+            look.atmosphere !== "none"));
+}
+// The cards a clip at `start` of `count` frames shows any part of.
+export function cardsIn(cards, start, count) {
+    return (cards ?? []).filter((card) => card.startFrame < start + count && card.startFrame + card.frames > start);
+}
+// Whether a clip's pixels depend on where it sits on the timeline: an atmosphere drifts with
+// the video's clock and a card is drawn at its own time, so such a clip is never reused at
+// another place.
+export function placed(edit, start, count) {
+    return ((edit.look !== undefined && edit.look.atmosphere !== "none") ||
+        cardsIn(edit.cards, start, count).length > 0);
+}
+// The filters that take the clip's picture from `input` to `output`, or undefined when there
+// is nothing to add. `start` is the clip's first frame on the timeline. Cards are read from
+// `cardsFile`, the clip's own script with its times counted from the clip's first frame
+// (`cards.ts`), and `fonts/`, both in the render's working folder.
+export function lookChain(edit, start, count, input, output, cardsFile = "cards.ass") {
+    const look = edit.look;
+    const steps = [];
+    let at = input;
+    let n = 0;
+    const next = () => {
+        n += 1;
+        return `[look${String(n)}]`;
+    };
+    const simple = (filters) => {
+        if (filters.length === 0)
+            return;
+        const label = next();
+        steps.push(`${at}${filters.join(",")}${label}`);
+        at = label;
+    };
+    if (look !== undefined && look.atmosphere !== "none") {
+        const texture = next();
+        const blended = next();
+        steps.push(`${atmosphereSource(edit, look.atmosphere, start)}${texture}`);
+        // Laid over the picture by its alpha, in the picture's own YUV: converting every frame
+        // to RGB for a screen blend doubled a clip's render time.
+        steps.push(`${at}${texture}overlay=shortest=1:format=yuv420${blended}`);
+        at = blended;
+    }
+    const after = [];
+    if (look !== undefined && look.vignette !== "off")
+        after.push(`vignette=angle=${vignetteAngle[look.vignette]}`);
+    if (cardsIn(edit.cards, start, count).length > 0)
+        after.push(`ass=filename=${cardsFile}:fontsdir=fonts`);
+    if (look !== undefined && look.grain !== "off")
+        after.push(`noise=c0s=${String(grainStrength[look.grain])}:c0f=t+u`);
+    simple(after);
+    if (steps.length === 0)
+        return undefined;
+    const last = steps.length - 1;
+    steps[last] = `${(steps[last] ?? "").slice(0, -at.length)}${output}`;
+    return steps.join(";");
+}
+const atmosphereOpacity = {
+    embers: "1",
+    dust: "0.6",
+    fog: "1",
+};
+// A still texture made once per clip, then moved: embers rise and drift left, dust wanders,
+// fog rolls sideways along the bottom of the frame. `scroll` wraps the texture round, which
+// leaves no seam for sparse specks, and the fog is mirrored side to side first so its wrap
+// has none either. The scroll starts where the timeline has it at the clip's first frame, so
+// the overlay runs on unbroken across cuts.
+//
+// The specks come from ffmpeg's `noise` (geq's random() repeats in visible columns): one
+// grey level of uniform noise marks about 1% of the pixels, and multiplying by a second,
+// flipped noise field thins them and varies their brightness. Everything is fixed numbers,
+// so the texture is the same on every run.
+function atmosphereSource(frame, atmosphere, start) {
+    const { width, height, fps } = frame;
+    const size = `${String(width)}x${String(height)}`;
+    const grid = (divisor) => `${String(Math.max(2, Math.round(width / divisor)))}x${String(Math.max(2, Math.round(height / divisor)))}`;
+    // A grey field of `grid` with about one pixel in a hundred lit, thinned by a second field
+    // cut at `cut` and scaled by `gain`; into `label`, still the grid's size.
+    const specks = (at, seed, cut, gain, label) => `color=c=0x808080:s=${at}:r=${String(fps)}:d=1,format=gbrp,split[${label}a][${label}b];` +
+        `[${label}a]noise=c0s=100:c0f=u:c0_seed=${String(seed)},lutrgb=g='if(eq(val,177),255,0)'[${label}c];` +
+        `[${label}b]noise=c0s=100:c0f=u:c0_seed=${String(seed + 2)},` +
+        `lutrgb=g='max(0,min(255,(val-${String(cut)})*${String(gain)}))',hflip,vflip[${label}d];` +
+        `[${label}c][${label}d]blend=all_mode=multiply[${label}]`;
+    // The green plane carries the texture; the mixer tints it into all three.
+    const tint = (r, g, b) => `colorchannelmixer=rr=0:rg=${String(r)}:rb=0:gr=0:gg=${String(g)}:gb=0:br=0:bg=${String(b)}:bb=0`;
+    // The texture as light over a transparent frame, made once before it loops: each pixel keeps
+    // its hue at full brightness, and how bright it was (times the atmosphere's strength)
+    // becomes how opaque it is, which is a screen blend's look for a dark background.
+    const peak = "max(r(X,Y),max(g(X,Y),b(X,Y)))";
+    const lit = (plane) => `if(gt(${peak},0),255*${plane}(X,Y)/${peak},0)`;
+    const light = `format=gbrap,geq=r='${lit("r")}':g='${lit("g")}':b='${lit("b")}':` +
+        `a='${peak}*${atmosphereOpacity[atmosphere]}',format=yuva420p`;
+    const moving = (h, v) => `${light},loop=loop=-1:size=1,setpts=N/(${String(fps)}*TB),` +
+        `scroll=h=${String(h)}:v=${String(v)}:hpos=${position(h, start)}:vpos=${position(v, start)}`;
+    if (atmosphere === "embers")
+        // Small sparks and a few large soft glows, orange, rising.
+        return (`${specks(grid(4), 7, 168, 24, "es")};${specks(grid(20), 3, 142, 7, "eb")};` +
+            `[es]scale=${size}:flags=bicubic,gblur=sigma=1.3,lutrgb=g='min(255,val*2.4)'[esx];` +
+            `[eb]scale=${size}:flags=bicubic,gblur=sigma=14,lutrgb=g='min(255,val*6)'[ebx];` +
+            `[esx][ebx]blend=all_mode=addition,${tint(1, 0.48, 0.12)},${moving(0.0003, 0.0022)}`);
+    if (atmosphere === "dust")
+        // Fine warm-white motes drifting slowly across.
+        return (`${specks(grid(3), 17, 160, 12, "ds")};` +
+            `[ds]scale=${size}:flags=bicubic,gblur=sigma=1.1,lutrgb=g='min(255,val*2)',` +
+            `${tint(1, 0.95, 0.85)},${moving(0.0005, -0.00025)}`);
+    // Soft blotches from a tiny noise field blown up and blurred, faded out towards the top.
+    return (`color=c=0x808080:s=${grid(80)}:r=${String(fps)}:d=1,format=gbrp,` +
+        "noise=c0s=100:c0f=u:c0_seed=23," +
+        `scale=${size}:flags=bicubic,gblur=sigma=70,lutrgb=g='max(0,min(255,(val-95)*3.2))',` +
+        "geq=r='g(X,Y)*pow(Y/H,1.6)':g='g(X,Y)*pow(Y/H,1.6)':b='g(X,Y)*pow(Y/H,1.6)'," +
+        "colorchannelmixer=rr=0.92:gg=0.95:bb=1,split[fa][fb];[fb]hflip[fc];[fa][fc]hstack," +
+        `${moving(0.0006, 0)},crop=${String(width)}:${String(height)}:0:0`);
+}
+// Where a texture scrolling `speed` of its size per frame has got to by frame `start`.
+function position(speed, start) {
+    const travelled = (((speed * start) % 1) + 1) % 1;
+    return travelled.toFixed(6);
+}