@gentbajko/slopify 0.5.0 → 0.6.1

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

@@ -0,0 +1,32 @@
+import { relative } from "node:path";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { probeDurationMs } from "./ffmpeg.js";
+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");
+    if (body.seconds <= 0)
+        throw new Error("the narration audio decodes to no sound");
+    const intro = await audio(deps, outputs, "audio_intro", dir, signal);
+    const outro = await audio(deps, outputs, "audio_outro", dir, signal);
+    return { body, intro, outro };
+}
+async function audio(deps, outputs, role, dir, signal) {
+    const output = outputs.find((candidate) => candidate.role === role);
+    if (output === undefined) {
+        return undefined;
+    }
+    const path = outputPath(deps.paths, output.projectId, output.path);
+    const durationMs = output.durationMs ?? (await probeDurationMs(deps.ffmpeg, path, signal, deps.log));
+    if (output.durationMs === null) {
+        // A provided file arrives with no duration; measuring it once is worth recording.
+        deps.db.prepare("UPDATE outputs SET duration_ms = ? WHERE id = ?").run(durationMs, output.id);
+        deps.log.write("info", "video.probe", {
+            projectId: output.projectId,
+            stage: "video",
+            detail: `${relative(dir, path)} is ${durationMs} ms`,
+        });
+    }
+    return { path, seconds: durationMs / 1000 };
+}

package/dist/slices/video/ffmpeg.js

@@ -1,11 +1,12 @@
 import { spawn } from "node:child_process";
+import { isAbsolute, resolve as resolvePath } from "node:path";
 import { zoomBy, zoomFrom, zoomTo } 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 115%.
+// meant to be smooth and linear. Four times the frame is enough at 122.5%.
 const prescale = 4;
 const sampleRate = 44100;
 const channelLayout = "stereo";
@@ -26,7 +27,7 @@ export function resolveFfmpeg(env, bundled) {
     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.");
 }
-export function renderArgs(plan) {
+export function renderArgs(plan, burnSubtitles = false) {
     const inputs = [];
     for (const slot of plan.images) {
         inputs.push("-i", slot.path);
@@ -52,23 +53,21 @@ export function renderArgs(plan) {
         "-y",
         ...inputs,
         "-filter_complex",
-        filterGraph(plan, audioAt),
+        filterGraph(plan, audioAt, burnSubtitles),
         "-map",
         "[v]",
-        "-map",
-        "[a]",
+        ...(plan.audio.length > 0 ? ["-map", "[a]"] : []),
         "-c:v",
         "libx264",
         "-pix_fmt",
         "yuv420p",
-        "-c:a",
-        "aac",
+        ...(plan.audio.length > 0 ? ["-c:a", "aac"] : ["-an"]),
         "-movflags",
         "+faststart",
         plan.output,
     ];
 }
-function filterGraph(plan, audioAt) {
+function filterGraph(plan, audioAt, burnSubtitles) {
     const chains = [];
     const wide = plan.width * prescale;
     const tall = plan.height * prescale;
@@ -80,16 +79,20 @@ function filterGraph(plan, audioAt) {
             `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[v]`);
+    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]");
     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.
         chains.push(`[${input}:a]aformat=sample_fmts=fltp:sample_rates=${sampleRate}:channel_layouts=${channelLayout}[a${at}]`);
     });
-    chains.push(`${audioAt.map((_input, at) => `[a${at}]`).join("")}concat=n=${audioAt.length}:v=0:a=1[a]`);
+    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(";");
 }
-// Odd images 100% → 115%, even images 115% → 100%, linear over the slot. `on` is
+// 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) {
@@ -120,9 +123,13 @@ export function runFfmpeg(run) {
             reject(new Error("the render was canceled before it started"));
             return;
         }
-        const child = spawn(run.bin, [...run.args], {
+        // Subtitle filters use their own working directory. An explicit relative binary
+        // still resolves from the app launch directory, where boot verified it.
+        const executable = !isAbsolute(run.bin) && /[\\/]/.test(run.bin) ? resolvePath(run.bin) : run.bin;
+        const child = spawn(executable, [...run.args], {
             stdio: ["ignore", "pipe", "pipe"],
             windowsHide: true,
+            ...(run.cwd === undefined ? {} : { cwd: run.cwd }),
         });
         const errors = [];
         let pending = "";

package/dist/slices/video/plan.js

@@ -4,20 +4,22 @@ const frames = {
     "16:9": { width: 1920, height: 1080 },
     "9:16": { width: 1080, height: 1920 },
 };
-// 100% → 115%, linear, centred, alternating per image. The three are written out
+// 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.15 - 1 is not 0.15 in binary floating point.
+// expression and 1.225 - 1 is not 0.225 in binary floating point.
 export const zoomFrom = 1;
-export const zoomTo = 1.15;
-export const zoomBy = 0.15;
+export const zoomTo = 1.225;
+export const zoomBy = 0.225;
 export function planRender(input) {
     if (input.images.length === 0) {
-        // Admission makes an image source mandatory, so an empty set is a bug upstream.
+        // 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");
     }
     const frame = frames[input.format];
-    const audio = timeline(input);
-    const totalSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    const audio = input.body === undefined ? [] : audioTimeline({ ...input, body: input.body });
+    const totalSeconds = input.body === undefined
+        ? input.images.length * 5
+        : audio.reduce((sum, segment) => sum + segment.seconds, 0);
     const totalFrames = Math.max(input.images.length, Math.round(totalSeconds * fps));
     return {
         width: frame.width,
@@ -33,13 +35,12 @@ export function planRender(input) {
 }
 // Intro, gap, body, gap, outro, with a gap only where the segment on
 // the other side of it exists.
-function timeline(input) {
+export function audioTimeline(input, minimumGap = 1 / fps) {
     const segments = [];
     const gap = { kind: "gap", path: null, seconds: input.gapSeconds };
-    // A gap shorter than one frame is no gap. The renderer formats a segment's length to
-    // milliseconds, so anything under that would become `-t 0.000`: an anullsrc input with
-    // no samples that still had to be counted in the audio concat.
-    const audible = input.gapSeconds >= 1 / fps;
+    // 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;
     if (input.intro !== undefined) {
         segments.push({ kind: "intro", path: input.intro.path, seconds: input.intro.seconds });
         if (audible) {

package/dist/slices/video/run.js

@@ -1,121 +1,46 @@
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, relative } from "node:path";
-import { transact } from "../../kernel/db/tx.js";
-import { projectById, setStageProgress } from "../admission/repo.js";
+import { relative } from "node:path";
+import { projectById } from "../admission/repo.js";
 import { outputPath, projectDir } from "../storage/layout.js";
-import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
-import { probeDurationMs, renderArgs, runFfmpeg } from "./ffmpeg.js";
+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 { planRender } from "./plan.js";
-// ceiling: progress is coalesced to one event per 500 ms, and the stage's progress
-// columns are written on the same tick so a page that reconnects mid-render sees a bar
-// rather than nothing.
-const progressIntervalMs = 500;
-// The previous video stays downloadable until the new render finishes. ffmpeg therefore writes
-// beside the finished file rather than over it, and the swap below is what replaces it. The
-// name keeps the `.mp4` extension because that is what ffmpeg picks its muxer from, and no row
-// ever names it: a download resolves an outputs row, and the boot reconcile collects a part
-// file left by a killed process as an orphan (`slices/storage/reconcile.ts`).
-const partName = "video.part.mp4";
-// The two outputs one render produces. Both are replaced together, so a project never
-// carries the video of one render beside the parameters of another.
-const renderRoles = ["video", "render_params"];
+import { writeExport } from "./write-export.js";
 export async function renderVideo(deps, context) {
     const { projectId } = context.stage;
     const project = projectById(deps.db, projectId);
-    if (project === undefined) {
+    if (!project)
         throw new Error(`project ${projectId} has no row`);
+    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);
+        return;
     }
     const outputs = outputsOf(deps.db, projectId);
     const dir = projectDir(deps.paths, projectId);
-    const target = outputPath(deps.paths, projectId, "video.mp4");
-    const body = await audio(deps, outputs, "audio_body", dir, context.signal);
-    if (body === undefined) {
-        throw new Error("the project has no narration audio to render against");
-    }
-    if (body.seconds <= 0) {
-        throw new Error("the narration audio decodes to no sound");
-    }
+    const narration = project.config.sources.audio === "off"
+        ? {}
+        : await audioInputs(deps, projectId, outputs, context.signal);
     const plan = planRender({
         format: project.format,
         gapSeconds: project.config.silenceGapSeconds,
-        ...withIntro(await audio(deps, outputs, "audio_intro", dir, context.signal)),
-        body,
-        ...withOutro(await audio(deps, outputs, "audio_outro", dir, context.signal)),
+        ...narration,
         images: slideshow(outputs).map((output) => outputPath(deps.paths, projectId, output.path)),
-        output: target,
-    });
-    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
-    // The plan is the record of what was rendered and names the file the user downloads,
-    // so it keeps the final path; only the ffmpeg invocation is pointed at the part file.
-    const part = outputPath(deps.paths, projectId, partName);
-    const totalMs = Math.round(plan.totalSeconds * 1000);
-    let announced = 0;
-    try {
-        // No retry and no timeout. A render that fails is terminal.
-        await runFfmpeg({
-            bin: deps.ffmpeg,
-            args: renderArgs({ ...plan, output: part }),
-            signal: context.signal,
-            log: deps.log,
-            onProgress: (elapsedMs) => {
-                const at = deps.clock.now().getTime();
-                if (at - announced < progressIntervalMs) {
-                    return;
-                }
-                announced = at;
-                const current = Math.min(elapsedMs, totalMs);
-                setStageProgress(deps.db, context.stage.id, current, totalMs);
-                context.emit({
-                    type: "stage.progress",
-                    projectId,
-                    stage: "video",
-                    current,
-                    total: totalMs,
-                });
-            },
-        });
-        // A cancel protects an output that was already stored, not one about to be. One
-        // landing between ffmpeg exiting and the rows below discards the render rather than
-        // reporting done to a page that pressed Cancel.
-        context.signal.throwIfAborted();
-    }
-    catch (error) {
-        // A partial render file is discarded, never kept or served. Only the part file: the
-        // previous video is a finished output and stays downloadable.
-        rmSync(part, { force: true });
-        throw error;
-    }
-    // The swap. Everything below replaces the previous render, and nothing above it could.
-    renameSync(part, target);
-    const params = outputPath(deps.paths, projectId, "render.json");
-    writeFileSync(params, `${JSON.stringify(recorded(plan, dir), null, 2)}\n`, { mode: 0o600 });
-    // No version history. The files were written under the names the previous render
-    // already used, so replacing the rows that named them is all that is left to do. In one
-    // transaction, or a crash between the delete and the insert would leave the finished
-    // video with no row and the boot reconcile would collect it. Read back rather than
-    // reused from above: the rows are what a download resolves.
-    transact(deps.db, () => {
-        for (const previous of outputsOf(deps.db, projectId)) {
-            if (renderRoles.includes(previous.role)) {
-                deleteOutput(deps.db, previous.id);
-            }
-        }
-        store(deps, projectId, "render_params", "render.json", null);
-        store(deps, projectId, "video", "video.mp4", totalMs);
+        output: outputPath(deps.paths, projectId, "video.mp4"),
     });
-    // Written as well as emitted: a page opened after the render reads the row, and the
-    // throttled in-flight writes would have left it frozen short of the end.
-    setStageProgress(deps.db, context.stage.id, totalMs, totalMs);
-    context.emit({
-        type: "stage.progress",
-        projectId,
-        stage: "video",
-        current: totalMs,
-        total: totalMs,
+    const subtitles = await prepareSubtitles(deps, context, plan.audio, plan);
+    await writeExport(deps, context, {
+        role: "video",
+        filename: "video.mp4",
+        partName: "video.part.mp4",
+        totalSeconds: plan.totalSeconds,
+        record: { ...recorded(plan, dir), subtitles: project.config.subtitles ?? null },
+        subtitles,
+        args: (part) => renderArgs({ ...plan, output: part }, subtitles?.burnIn),
     });
-    // Videos rendered (completed renders). One event per swap, so a render that failed or was
-    // canceled counts nothing and a re-render counts again No provider: ffmpeg is the machine's
-    // own, not a service.
     deps.count("stage.completed", { stage: "video" });
 }
 // Written with project-relative paths, so the record of what was rendered can be read
@@ -138,41 +63,3 @@ function slideshow(outputs) {
         .filter((output) => output.role === "image")
         .toSorted((left, right) => (left.meta.index ?? 0) - (right.meta.index ?? 0));
 }
-async function audio(deps, outputs, role, dir, signal) {
-    const output = outputs.find((candidate) => candidate.role === role);
-    if (output === undefined) {
-        return undefined;
-    }
-    const path = outputPath(deps.paths, output.projectId, output.path);
-    const durationMs = output.durationMs ?? (await probeDurationMs(deps.ffmpeg, path, signal, deps.log));
-    if (output.durationMs === null) {
-        // A provided file arrives with no duration; measuring it once is worth recording.
-        deps.db.prepare("UPDATE outputs SET duration_ms = ? WHERE id = ?").run(durationMs, output.id);
-        deps.log.write("info", "video.probe", {
-            projectId: output.projectId,
-            stage: "video",
-            detail: `${relative(dir, path)} is ${durationMs} ms`,
-        });
-    }
-    return { path, seconds: durationMs / 1000 };
-}
-function withIntro(intro) {
-    return intro === undefined ? {} : { intro };
-}
-function withOutro(outro) {
-    return outro === undefined ? {} : { outro };
-}
-function store(deps, projectId, role, path, durationMs) {
-    insertOutput(deps.db, {
-        id: deps.ids.next(),
-        projectId,
-        stageKind: "video",
-        role,
-        path,
-        originalFilename: null,
-        bytes: statSync(outputPath(deps.paths, projectId, path)).size,
-        durationMs,
-        meta: {},
-        createdAt: deps.clock.now().toISOString(),
-    });
-}

package/dist/slices/video/write-export.js

@@ -0,0 +1,163 @@
+import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+import { transact } from "../../kernel/db/tx.js";
+import { setStageProgress } from "../admission/repo.js";
+import { outputPath } from "../storage/layout.js";
+import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
+import { subtitleRoles } from "../subtitles/prepare.js";
+import { runFfmpeg } from "./ffmpeg.js";
+const progressIntervalMs = 500;
+const renderRoles = [
+    "video",
+    "audio_export",
+    "render_params",
+    ...subtitleRoles,
+];
+// Both local exports retain the previous finished asset until ffmpeg succeeds and
+// the abort check passes. The part file keeps its muxer's filename extension.
+export async function writeExport(deps, context, output) {
+    const { projectId } = context.stage;
+    const target = outputPath(deps.paths, projectId, output.filename);
+    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    // The plan is the record of what was rendered and names the file the user downloads,
+    // so it keeps the final path; only the ffmpeg invocation is pointed at the part file.
+    const part = outputPath(deps.paths, projectId, output.partName);
+    const totalMs = Math.round(output.totalSeconds * 1000);
+    let announced = 0;
+    try {
+        // No retry and no timeout. A render that fails is terminal.
+        await runFfmpeg({
+            bin: deps.ffmpeg,
+            args: output.args(part),
+            cwd: output.subtitles?.directory,
+            signal: context.signal,
+            log: deps.log,
+            onProgress: (elapsedMs) => {
+                const at = deps.clock.now().getTime();
+                if (at - announced < progressIntervalMs) {
+                    return;
+                }
+                announced = at;
+                const current = output.subtitles === undefined
+                    ? Math.min(elapsedMs, totalMs)
+                    : Math.round((0.35 + 0.65 * Math.min(elapsedMs / totalMs, 1)) * totalMs);
+                setStageProgress(deps.db, context.stage.id, current, totalMs);
+                context.emit({
+                    type: "stage.progress",
+                    projectId,
+                    stage: "video",
+                    current,
+                    total: totalMs,
+                });
+            },
+        });
+        // A cancel protects an output that was already stored, not one about to be. One
+        // landing between ffmpeg exiting and the rows below discards the render rather than
+        // reporting done to a page that pressed Cancel.
+        context.signal.throwIfAborted();
+    }
+    catch (error) {
+        // A partial render file is discarded, never kept or served. Only the part file: the
+        // previous export is a finished output and stays downloadable.
+        rmSync(part, { force: true });
+        if (output.subtitles !== undefined)
+            rmSync(output.subtitles.directory, { recursive: true, force: true });
+        throw error;
+    }
+    const params = outputPath(deps.paths, projectId, "render.json");
+    const previousOutputs = outputsOf(deps.db, projectId);
+    const replaced = [];
+    const paramsPart = outputPath(deps.paths, projectId, "render.part.json");
+    let committed = false;
+    try {
+        writeFileSync(paramsPart, `${JSON.stringify(output.record, null, 2)}\n`, { mode: 0o600 });
+        // The DB commit can fail after ffmpeg succeeds. Keep rollback copies until all
+        // media, caption and font rows commit, so a failed export keeps its old playback.
+        for (const path of [target, params]) {
+            const saved = { path, backup: `${path}.previous`, existed: existsSync(path), swapped: false };
+            if (saved.existed)
+                copyFileSync(path, saved.backup);
+            replaced.push(saved);
+        }
+        for (const saved of replaced) {
+            renameSync(saved.path === target ? part : paramsPart, saved.path);
+            saved.swapped = true;
+        }
+        transact(deps.db, () => {
+            for (const previous of previousOutputs) {
+                if (renderRoles.includes(previous.role))
+                    deleteOutput(deps.db, previous.id);
+            }
+            store(deps, projectId, "render_params", "render.json", null);
+            store(deps, projectId, output.role, output.filename, totalMs, {
+                subtitlesMode: output.subtitles === undefined ? "off" : output.subtitles.burnIn ? "burn-in" : "files",
+            });
+            for (const asset of output.subtitles?.assets ?? [])
+                store(deps, projectId, asset.role, asset.path, null);
+        });
+        committed = true;
+    }
+    catch (error) {
+        for (const saved of replaced) {
+            if (!saved.swapped)
+                continue;
+            if (saved.existed)
+                renameSync(saved.backup, saved.path);
+            else
+                rmSync(saved.path, { force: true });
+            saved.swapped = false;
+        }
+        rmSync(part, { force: true });
+        rmSync(paramsPart, { force: true });
+        if (output.subtitles !== undefined)
+            rmSync(output.subtitles.directory, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        for (const saved of replaced) {
+            if (!committed && saved.swapped)
+                continue;
+            try {
+                rmSync(saved.backup, { force: true });
+            }
+            catch {
+                /* A retained backup is collected at the next boot. */
+            }
+        }
+    }
+    const kept = new Set(outputsOf(deps.db, projectId).map((one) => one.path));
+    for (const previous of previousOutputs) {
+        if (renderRoles.includes(previous.role) && !kept.has(previous.path)) {
+            try {
+                rmSync(outputPath(deps.paths, projectId, previous.path), { force: true });
+            }
+            catch {
+                /* Boot reconciliation collects a file that could not be removed. */
+            }
+        }
+    }
+    // Written as well as emitted: a page opened after the render reads the row, and the
+    // throttled in-flight writes would have left it frozen short of the end.
+    setStageProgress(deps.db, context.stage.id, totalMs, totalMs);
+    context.emit({
+        type: "stage.progress",
+        projectId,
+        stage: "video",
+        current: totalMs,
+        total: totalMs,
+    });
+}
+function store(deps, projectId, role, path, durationMs, meta = {}) {
+    insertOutput(deps.db, {
+        id: deps.ids.next(),
+        projectId,
+        stageKind: "video",
+        role,
+        path,
+        originalFilename: null,
+        bytes: statSync(outputPath(deps.paths, projectId, path)).size,
+        durationMs,
+        meta,
+        createdAt: deps.clock.now().toISOString(),
+    });
+}