@gentbajko/slopify 2.0.2 → 2.1.0

package/dist/slices/video/audio-inputs.js

@@ -5,9 +5,9 @@ export async function audioInputs(deps, projectId, outputs, signal) {
     const dir = projectDir(deps.paths, projectId);
     const body = await audio(deps, outputs, "audio_body", dir, signal);
     if (!body)
-        throw new Error("the project has no narration audio to render against");
+        throw new Error("The video has no narration audio to play. Let the Narration stage finish, then Retry stage.");
     if (body.seconds <= 0)
-        throw new Error("the narration audio decodes to no sound");
+        throw new Error("The narration audio contains no sound; the file may be damaged or empty. Regenerate the narration (or upload a different audio file in Edit project → Narration), then Retry stage.");
     const intro = await audio(deps, outputs, "audio_intro", dir, signal);
     const outro = await audio(deps, outputs, "audio_outro", dir, signal);
     return { body, intro, outro };

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

@@ -0,0 +1,73 @@
+import { z } from "zod";
+// The edit list is the whole video as data: what plays, for how many frames, how it moves,
+// and the audio under it. Planning (`plan.ts`) writes one and the renderer (`ffmpeg.ts`,
+// `slideshow.ts`) reads nothing else, so a new kind of shot or movement is a new case
+// here, in the planner and in the clip filter, and never a change to how the render runs.
+// It is plain JSON, recorded in render.json, and carries a version so a later Slopify can
+// tell an older list from its own.
+//
+// Extension points, none of them built yet: `Shot.source` gains a `video` kind for clips,
+// `Shot.transition` says how a shot enters from the one before, and effects (a colour
+// grade, a text card) become a list on the shot. Each is a new optional field or union
+// case, so a version-1 list stays readable; a change that alters what an existing field
+// means bumps the version instead.
+export const editListVersion = 1;
+// The same list with every file path passed through `map`: render.json records paths
+// relative to the project folder.
+export function withPaths(edit, map) {
+    return {
+        ...edit,
+        audio: edit.audio.map((segment) => ({
+            ...segment,
+            path: segment.path === null ? null : map(segment.path),
+        })),
+        shots: edit.shots.map((shot) => ({
+            ...shot,
+            source: { ...shot.source, path: map(shot.source.path) },
+        })),
+    };
+}
+const share = z.number().min(0).max(1);
+const point = z.object({ x: share, y: share }).strict();
+const percent = z.number().min(0);
+const motionSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("zoom"), direction: z.enum(["in", "out"]), percent }).strict(),
+    z.object({ kind: z.literal("pan"), from: point, to: point, percent }).strict(),
+    z.object({ kind: z.literal("still") }).strict(),
+]);
+const count = z.number().int().positive();
+const editListSchema = z
+    .object({
+    version: z.literal(editListVersion),
+    width: count,
+    height: count,
+    fps: count,
+    audio: z.array(z
+        .object({
+        kind: z.enum(["intro", "body", "outro", "gap", "edge"]),
+        path: z.string().nullable(),
+        seconds: z.number().nonnegative(),
+    })
+        .strict()),
+    shots: z
+        .array(z
+        .object({
+        source: z.object({ kind: z.literal("image"), path: z.string().min(1) }).strict(),
+        frames: count,
+        motion: motionSchema,
+    })
+        .strict())
+        .min(1),
+})
+    .strict();
+// Reads a recorded edit list back. Strict, so a list written by a newer Slopify, with a
+// field or kind this one does not know, is refused rather than rendered without it.
+export function readEditList(value) {
+    const version = typeof value === "object" && value !== null && "version" in value ? value.version : undefined;
+    if (version !== editListVersion)
+        throw new Error(`This video's edit list is version ${String(version)}, and this Slopify reads version ${editListVersion}. Update Slopify, or use Re-run section on Video to plan it again.`);
+    const parsed = editListSchema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`This video's edit list is damaged (${parsed.error.issues[0]?.path.join(".") || "the list"}: ${parsed.error.issues[0]?.message ?? "not readable"}). Use Re-run section on Video to plan it again.`);
+    return parsed.data;
+}

package/dist/slices/video/ffmpeg.js

@@ -1,12 +1,14 @@
 import { spawn } from "node:child_process";
 import { isAbsolute, resolve as resolvePath } from "node:path";
-import { zoomBy, zoomFrom, zoomTo } from "./plan.js";
+import { decimal, zoomRange } from "./plan.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.
 // zoompan works on a still that has been pre-scaled, because it steps the zoom in
 // sub-pixel increments and a source at output resolution visibly jitters where the zoom is
-// meant to be smooth and linear. Four times the frame is enough at 122.5%.
+// meant to be smooth and linear. A pan steps its crop window in whole source pixels, so
+// the same four times gives it quarter-pixel steps on screen. Four times the frame is
+// enough at 122.5%.
 const prescale = 4;
 const sampleRate = 44100;
 const channelLayout = "stereo";
@@ -24,64 +26,75 @@ export function resolveFfmpeg(env, bundled) {
     }
     // Never PATH: a Slopify that quietly rendered with whichever ffmpeg the machine
     // happens to carry would not be testing the binary it ships with.
-    throw new Error("No ffmpeg binary is available. Slopify ships one through ffmpeg-static; if this " +
-        "platform has no build, point SLOPIFY_FFMPEG at an ffmpeg executable.");
+    throw new Error("Slopify can't find ffmpeg, the tool it uses to make audio and video: its bundled copy is " +
+        "missing for this computer. Reinstall Slopify, or set the SLOPIFY_FFMPEG environment " +
+        "variable to the path of an ffmpeg program.");
 }
-export function renderArgs(plan, burnSubtitles = false) {
-    const inputs = [];
-    for (const slot of plan.images) {
-        inputs.push("-i", slot.path);
-    }
-    const audioAt = [];
-    for (const segment of plan.audio) {
-        audioAt.push(plan.images.length + audioAt.length);
-        if (segment.path === null) {
-            inputs.push("-f", "lavfi", "-t", seconds(segment.seconds), "-i", `anullsrc=r=${sampleRate}:cl=${channelLayout}`);
-            continue;
+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]);
+        let name = named.get(key);
+        if (name === undefined) {
+            name = `c${clips.length + 1}.mp4`;
+            named.set(key, name);
+            clips.push({ name, shot });
         }
-        inputs.push("-i", segment.path);
-    }
+        return name;
+    });
+    return { clips, order };
+}
+// 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";
+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 [
-        "-hide_banner",
-        "-nostdin",
-        "-loglevel",
-        "error",
-        // Progress on stdout keeps stderr free to carry only what went wrong.
-        "-progress",
-        "pipe:1",
-        "-nostats",
-        "-y",
-        ...inputs,
+        ...progressArgs,
+        "-i",
+        shot.source.path,
         "-filter_complex",
-        filterGraph(plan, audioAt, burnSubtitles),
+        `[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]`,
         "-map",
         "[v]",
-        ...(plan.audio.length > 0 ? ["-map", "[a]"] : []),
-        "-c:v",
-        "libx264",
-        "-pix_fmt",
-        "yuv420p",
-        ...(plan.audio.length > 0 ? ["-c:a", "aac"] : ["-an"]),
-        "-movflags",
-        "+faststart",
-        plan.output,
+        ...videoCodec,
+        ...(intermediate ? ["-crf", intermediateCrf] : []),
+        "-an",
+        output,
     ];
 }
-function filterGraph(plan, audioAt, burnSubtitles) {
+// 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) {
+    return `ffconcat version 1.0\n${order.map((name) => `file ${name}`).join("\n")}\n`;
+}
+export function joinArgs(edit, output, list, burnSubtitles = false) {
+    const inputs = ["-f", "concat", "-i", list];
+    const audioAt = [];
+    for (const segment of edit.audio) {
+        audioAt.push(1 + audioAt.length);
+        if (segment.path === null) {
+            inputs.push("-f", "lavfi", "-t", seconds(segment.seconds), "-i", `anullsrc=r=${sampleRate}:cl=${channelLayout}`);
+            continue;
+        }
+        inputs.push("-i", segment.path);
+    }
     const chains = [];
-    const wide = plan.width * prescale;
-    const tall = plan.height * prescale;
-    plan.images.forEach((slot, at) => {
-        chains.push(`[${at}: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='${zoomExpression(slot)}':d=${slot.frames}:` +
-            `x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':` +
-            `s=${plan.width}x${plan.height}:fps=${plan.fps},setsar=1[v${at}]`);
-    });
-    chains.push(`${plan.images.map((_slot, at) => `[v${at}]`).join("")}concat=n=${plan.images.length}:v=1:a=0${burnSubtitles ? "[uncaptioned]" : "[v]"}`);
     if (burnSubtitles)
-        chains.push("[uncaptioned]ass=filename=subtitles.ass:fontsdir=fonts[v]");
+        chains.push("[0:v]ass=filename=subtitles.ass:fontsdir=fonts[v]");
     audioAt.forEach((input, at) => {
         // The segments come from different files and the silence from lavfi, so they are
         // brought to one format before concat, which refuses to join mismatched streams.
@@ -90,17 +103,71 @@ function filterGraph(plan, audioAt, burnSubtitles) {
     if (audioAt.length > 0) {
         chains.push(`${audioAt.map((_input, at) => `[a${at}]`).join("")}concat=n=${audioAt.length}:v=0:a=1[a]`);
     }
-    return chains.join(";");
+    return [
+        ...progressArgs,
+        ...inputs,
+        ...(chains.length > 0 ? ["-filter_complex", chains.join(";")] : []),
+        "-map",
+        burnSubtitles ? "[v]" : "0:v",
+        ...(edit.audio.length > 0 ? ["-map", "[a]"] : []),
+        ...(burnSubtitles ? videoCodec : ["-c:v", "copy"]),
+        ...(edit.audio.length > 0 ? ["-c:a", "aac"] : ["-an"]),
+        "-movflags",
+        "+faststart",
+        output,
+    ];
 }
-// Odd images 100% → 122.5%, even images 122.5% → 100%, linear over the slot. `on` is
-// zoompan's output frame counter, 0 to d-1, and a one-frame slot has no span to divide
-// by, so it holds the zoom it starts at.
-function zoomExpression(slot) {
-    const span = slot.frames - 1;
-    if (slot.zoom === "in") {
-        return span < 1 ? String(zoomFrom) : `${zoomFrom}+${zoomBy}*on/${span}`;
+const progressArgs = [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    // Progress on stdout keeps stderr free to carry only what went wrong.
+    "-progress",
+    "pipe:1",
+    "-nostats",
+    "-y",
+];
+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) {
+    if (motion.kind === "still")
+        return undefined;
+    const range = zoomRange(motion.percent);
+    if (range === undefined)
+        return undefined;
+    const span = frames - 1;
+    if (motion.kind === "zoom") {
+        // Zoom in rises from 100%, zoom out falls back to it, linear over the shot.
+        const z = motion.direction === "in"
+            ? span < 1
+                ? range.from
+                : `${range.from}+${range.by}*on/${span}`
+            : span < 1
+                ? range.to
+                : `${range.to}-${range.by}*on/${span}`;
+        return { z, x: centredX, y: centredY };
     }
-    return span < 1 ? String(zoomTo) : `${zoomTo}-${zoomBy}*on/${span}`;
+    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)})`,
+    };
+}
+// 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) {
+    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}`;
 }
 function seconds(value) {
     return value.toFixed(3);
@@ -180,7 +247,7 @@ export function runFfmpeg(run) {
         run.signal.addEventListener("abort", stop, { once: true });
         child.on("error", (error) => {
             run.signal.removeEventListener("abort", stop);
-            reject(new Error(`ffmpeg could not be started: ${error.message}`));
+            reject(new Error(`Slopify could not start ffmpeg, the tool it uses to make audio and video (${error.message}). Reinstall Slopify, or if you set SLOPIFY_FFMPEG, check that it points to a working ffmpeg program.`));
         });
         child.on("close", (code, signal) => {
             run.signal.removeEventListener("abort", stop);
@@ -240,7 +307,8 @@ function messageOf(error) {
 }
 function failure(code, signal, errors) {
     const ended = code === null ? `killed by ${signal ?? "a signal"}` : `exited with code ${code}`;
-    return errors.length === 0
+    const said = errors.length === 0
         ? `ffmpeg ${ended} and wrote nothing to its error stream`
         : `ffmpeg ${ended}: ${errors.join(" / ")}`;
+    return `The audio/video export failed (${said}). Retry stage; if it fails again, make sure your disk has free space (see Settings → Backup & storage), then use Download diagnostics in Settings and report it.`;
 }

package/dist/slices/video/motion.js

@@ -0,0 +1,51 @@
+// floor: a pan needs room to travel, and a crop of 100% leaves none. Below 10% the
+// travel is a few percent of the frame over the whole shot, which reads as a wobble
+// rather than a pan, so a pan uses the project's zoom or 10%, whichever is more; with
+// Zoom (%) at 0 the pans still move and zoom motions keep the still still.
+export const panMinimumPercent = 10;
+const left = { x: 0, y: 0.5 };
+const right = { x: 1, y: 0.5 };
+const top = { x: 0.5, y: 0 };
+const bottom = { x: 0.5, y: 1 };
+// The order the pans take turns in: across one way, back, down, back up.
+const pans = [
+    [left, right],
+    [right, left],
+    [top, bottom],
+    [bottom, top],
+];
+// The motion for the slot at `at` (0-based) of the timeline. Everything turns on the
+// slot's place and nothing else, so the same project plans the same list every time and
+// a re-render is identical. Zoom: in, out, in, ... Pan: the four directions above in
+// turn. Mixed: zoom and pan take turns, each keeping its own alternation, so the slots
+// run zoom in, pan left to right, zoom out, pan right to left, zoom in, pan top to
+// bottom, ...
+export function motionFor(style, at, zoomPercent) {
+    switch (style) {
+        case "still":
+            return { kind: "still" };
+        case "zoom":
+            return zoom(at, zoomPercent);
+        case "pan":
+            return pan(at, zoomPercent);
+        case "mixed":
+            return at % 2 === 0 ? zoom(at / 2, zoomPercent) : pan((at - 1) / 2, zoomPercent);
+    }
+}
+function zoom(turn, percent) {
+    // Rounded to the half steps admission allows, which is what the renderer can write
+    // exactly; 0% is no zoom at all.
+    const halves = Math.round(percent * 2);
+    if (halves <= 0)
+        return { kind: "still" };
+    return { kind: "zoom", direction: turn % 2 === 0 ? "in" : "out", percent: halves / 2 };
+}
+function pan(turn, percent) {
+    const [from, to] = pans[turn % pans.length] ?? [left, right];
+    return {
+        kind: "pan",
+        from,
+        to,
+        percent: Math.max(Math.round(percent * 2) / 2, panMinimumPercent),
+    };
+}

package/dist/slices/video/plan.js

@@ -1,46 +1,79 @@
+import { editListVersion, } from "./edit-list.js";
+import { motionFor } from "./motion.js";
 // 30 fps, 1920×1080 for 16:9 and 1080×1920 for 9:16.
 export const fps = 30;
 const frames = {
     "16:9": { width: 1920, height: 1080 },
     "9:16": { width: 1080, height: 1920 },
 };
-// 100% → 122.5%, linear, centred, alternating per image. The three are written out
-// rather than derived from one another, because they are formatted into an ffmpeg
-// expression and 1.225 - 1 is not 0.225 in binary floating point.
-export const zoomFrom = 1;
-export const zoomTo = 1.225;
-export const zoomBy = 0.225;
+// A zoom shot zooms linearly and centred between 100% and 100% + the project's zoom
+// percent; a pan holds 100% + its percent while it travels. The ends are formatted into an ffmpeg
+// expression, so they are built from whole thousandths as decimal text rather than by
+// float arithmetic: 1 + 0.225 is exact, but 1.225 - 1 is not 0.225 in binary floating
+// point, and a percent in half steps is always a whole number of thousandths.
+export const zoomFrom = "1";
+// undefined for 0%: the still does not move.
+export function zoomRange(percent) {
+    const thousandths = Math.round(percent * 10);
+    if (thousandths <= 0)
+        return undefined;
+    return { from: zoomFrom, to: decimal(1000 + thousandths), by: decimal(thousandths) };
+}
+// Whole thousandths as decimal text, for anything that goes into an ffmpeg expression.
+export function decimal(thousandths) {
+    const fraction = String(thousandths % 1000)
+        .padStart(3, "0")
+        .replace(/0+$/, "");
+    const whole = String(Math.floor(thousandths / 1000));
+    return fraction === "" ? whole : `${whole}.${fraction}`;
+}
 export function planRender(input) {
     if (input.images.length === 0) {
         // Admission permits Video only with an image source, so an empty set is a bug upstream.
-        throw new Error("a render needs at least one image");
+        throw new Error("The video needs at least one image, but there are none. Check the Images section in Edit project, then Retry stage.");
     }
     const frame = frames[input.format];
     const audio = input.body === undefined ? [] : audioTimeline({ ...input, body: input.body });
+    // A silent video shows every image once, which is the one length it has to go on.
     const totalSeconds = input.body === undefined
-        ? input.images.length * 5
+        ? input.images.length * input.imageSeconds
         : audio.reduce((sum, segment) => sum + segment.seconds, 0);
-    const totalFrames = Math.max(input.images.length, Math.round(totalSeconds * fps));
+    const totalFrames = Math.max(1, Math.round(totalSeconds * fps));
     return {
-        width: frame.width,
-        height: frame.height,
-        fps,
         gapSeconds: input.gapSeconds,
-        audio,
-        images: slots(input.images, totalFrames),
+        edgeSeconds: input.edgeSeconds,
+        imageSeconds: input.imageSeconds,
+        zoomPercent: input.zoomPercent,
+        motionStyle: input.motionStyle,
+        editList: {
+            version: editListVersion,
+            width: frame.width,
+            height: frame.height,
+            fps,
+            audio,
+            shots: shots(input, Math.max(1, Math.round(input.imageSeconds * fps)), totalFrames),
+        },
         totalFrames,
         totalSeconds,
         output: input.output,
     };
 }
-// Intro, gap, body, gap, outro, with a gap only where the segment on
-// the other side of it exists.
+export function spoken(kind) {
+    return kind !== "gap" && kind !== "edge";
+}
+// Edge, intro, gap, body, gap, outro, edge, with a gap only where the segment on the other
+// side of it exists. Captions walk these same segments, so the lead-in shifts every cue.
 export function audioTimeline(input, minimumGap = 1 / fps) {
     const segments = [];
     const gap = { kind: "gap", path: null, seconds: input.gapSeconds };
+    const edge = { kind: "edge", path: null, seconds: input.edgeSeconds };
     // Video keeps its existing minimum of one frame. WAV passes one sample instead,
     // because its gap duration is independent of the slideshow's frame rate.
     const audible = input.gapSeconds >= minimumGap;
+    const edged = input.edgeSeconds >= minimumGap;
+    if (edged) {
+        segments.push(edge);
+    }
     if (input.intro !== undefined) {
         segments.push({ kind: "intro", path: input.intro.path, seconds: input.intro.seconds });
         if (audible) {
@@ -54,19 +87,20 @@ export function audioTimeline(input, minimumGap = 1 / fps) {
         }
         segments.push({ kind: "outro", path: input.outro.path, seconds: input.outro.seconds });
     }
+    if (edged) {
+        segments.push(edge);
+    }
     return segments;
 }
-// The slot is the total divided by the image count, and the last image absorbs the frame
-// rounding. One image fills the whole length. ceiling: every slot holds at least one frame, so
-// a run with more images than the timeline has frames renders slightly longer than its audio
-// rather than failing.
-function slots(paths, totalFrames) {
-    const each = Math.max(1, Math.floor(totalFrames / paths.length));
-    return paths.map((path, at) => ({
-        path,
-        index: at + 1,
-        frames: at === paths.length - 1 ? Math.max(1, totalFrames - each * at) : each,
-        // Odd images zoom in, even images zoom out.
-        zoom: at % 2 === 0 ? "in" : "out",
+// The images take turns in slideshow order, each for `each` frames, starting over after the
+// last until the timeline is full; the last shot is cut to what is left. A timeline shorter
+// than one shot is a single shot. The motion goes by the shot's place, not the image
+// (`motion.ts`), so an image that comes round again may move another way.
+function shots(input, each, totalFrames) {
+    const count = Math.ceil(totalFrames / each);
+    return Array.from({ length: count }, (_value, at) => ({
+        source: { kind: "image", path: input.images[at % input.images.length] ?? "" },
+        frames: Math.min(each, totalFrames - each * at),
+        motion: motionFor(input.motionStyle, at, input.zoomPercent),
     }));
 }

package/dist/slices/video/reuse-audio.js

@@ -6,6 +6,8 @@ const planSchema = z.object({
     channels: z.number(),
     codec: z.string(),
     gapSeconds: z.number(),
+    // Absent from records written before the edge silence existed, which then never match.
+    edgeSeconds: z.number().optional(),
     totalSeconds: z.number(),
     audio: z.array(z.object({ kind: z.string(), path: z.string().nullable(), seconds: z.number() })),
     output: z.string(),

package/dist/slices/video/run.js

@@ -5,18 +5,19 @@ import { outputsOf } from "../storage/repo.js";
 import { prepareSubtitles } from "../subtitles/prepare.js";
 import { exportAudioWav } from "./audio-export.js";
 import { audioInputs } from "./audio-inputs.js";
-import { renderArgs } from "./ffmpeg.js";
+import { withPaths } from "./edit-list.js";
 import { planRender } from "./plan.js";
+import { renderSlideshow } from "./slideshow.js";
 import { writeExport } from "./write-export.js";
 export async function renderVideo(deps, context) {
     const { projectId } = context.stage;
     const project = projectById(deps.db, projectId);
     if (!project)
-        throw new Error(`project ${projectId} has no row`);
+        throw new Error("This project no longer exists; it may have been deleted while it was running.");
     if (project.config.sources.video === "off") {
         if (project.config.sources.audio === "off")
-            throw new Error("the project has no media export enabled");
-        await exportAudioWav(deps, context, project.config.silenceGapSeconds);
+            throw new Error("There is nothing to export because both video and narration are turned off for this project. Turn one on in Edit project, then Retry stage.");
+        await exportAudioWav(deps, context, project.config.silenceGapSeconds, project.config.edgeSilenceSeconds);
         return;
     }
     const outputs = outputsOf(deps.db, projectId);
@@ -27,11 +28,15 @@ export async function renderVideo(deps, context) {
     const plan = planRender({
         format: project.format,
         gapSeconds: project.config.silenceGapSeconds,
+        edgeSeconds: project.config.edgeSilenceSeconds,
+        imageSeconds: project.config.imageSeconds,
+        zoomPercent: project.config.zoomPercent,
+        motionStyle: project.config.motionStyle,
         ...narration,
         images: slideshow(outputs).map((output) => outputPath(deps.paths, projectId, output.path)),
         output: outputPath(deps.paths, projectId, "video.mp4"),
     });
-    const subtitles = await prepareSubtitles(deps, context, plan.audio, plan);
+    const subtitles = await prepareSubtitles(deps, context, plan.editList.audio, plan.editList);
     await writeExport(deps, context, {
         role: "video",
         filename: "video.mp4",
@@ -39,7 +44,17 @@ export async function renderVideo(deps, context) {
         totalSeconds: plan.totalSeconds,
         record: { ...recorded(plan, dir), subtitles: project.config.subtitles ?? null },
         subtitles,
-        args: (part) => renderArgs({ ...plan, output: part }, subtitles?.burnIn),
+        render: (part, onProgress) => renderSlideshow({
+            bin: deps.ffmpeg,
+            edit: plan.editList,
+            output: part,
+            burnSubtitles: subtitles?.burnIn ?? false,
+            cwd: subtitles?.directory,
+            scratch: dir,
+            signal: context.signal,
+            log: deps.log,
+            onProgress,
+        }),
     });
     deps.count("stage.completed", { stage: "video" });
 }
@@ -48,15 +63,11 @@ export async function renderVideo(deps, context) {
 function recorded(plan, dir) {
     return {
         ...plan,
-        audio: plan.audio.map((segment) => ({
-            ...segment,
-            path: segment.path === null ? null : relative(dir, segment.path),
-        })),
-        images: plan.images.map((slot) => ({ ...slot, path: relative(dir, slot.path) })),
+        editList: withPaths(plan.editList, (path) => relative(dir, path)),
         output: relative(dir, plan.output),
     };
 }
-// Every slideshow image appears exactly once, in slideshow order.
+// Every slideshow image, once each, in slideshow order; the plan cycles through them.
 // The thumbnail is a different role, so it is never in this list.
 function slideshow(outputs) {
     return outputs

package/dist/slices/video/slideshow.js

@@ -0,0 +1,48 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { clipArgs, concatList, joinArgs, runFfmpeg, slideshowClips } from "./ffmpeg.js";
+// estimate: a zoompan frame from a 4x still costs several plain encoded frames, and a
+// copying join is nearly free, so progress is weighted by that rather than by clock time.
+const clipWeight = 4;
+const copyWeight = 0.05;
+export async function renderSlideshow(run) {
+    const { edit } = run;
+    const { clips, order } = slideshowClips(edit);
+    const msOf = (frames) => (frames / edit.fps) * 1000;
+    const joinMs = msOf(edit.shots.reduce((sum, shot) => sum + shot.frames, 0));
+    // Progress is reported against the video's length, the longer of picture and sound.
+    const totalMs = Math.max(joinMs, edit.audio.reduce((sum, segment) => sum + segment.seconds * 1000, 0));
+    const clipMs = clips.reduce((sum, clip) => sum + msOf(clip.shot.frames), 0);
+    const work = clipMs * clipWeight + joinMs * (run.burnSubtitles ? 1 : copyWeight);
+    const report = (done) => {
+        run.onProgress(work > 0 ? Math.round((Math.min(done, work) / work) * totalMs) : 0);
+    };
+    const workspace = mkdtempSync(join(run.scratch, "render-"));
+    try {
+        let rendered = 0;
+        for (const clip of clips) {
+            const before = rendered;
+            await runFfmpeg({
+                bin: run.bin,
+                args: clipArgs(edit, clip.shot, join(workspace, clip.name), run.burnSubtitles),
+                signal: run.signal,
+                log: run.log,
+                onProgress: (elapsedMs) => report(before + elapsedMs * clipWeight),
+            });
+            rendered += msOf(clip.shot.frames) * clipWeight;
+        }
+        const list = join(workspace, "slides.ffconcat");
+        writeFileSync(list, concatList(order), { mode: 0o600 });
+        await runFfmpeg({
+            bin: run.bin,
+            cwd: run.cwd,
+            args: joinArgs(edit, run.output, list, run.burnSubtitles),
+            signal: run.signal,
+            log: run.log,
+            onProgress: (elapsedMs) => report(rendered + elapsedMs * (run.burnSubtitles ? 1 : copyWeight)),
+        });
+    }
+    finally {
+        rmSync(workspace, { recursive: true, force: true });
+    }
+}