@gentbajko/slopify 3.1.1 → 3.2.1

package/dist/slices/video/slideshow.js

@@ -2,12 +2,16 @@ import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "nod
 import { extname, join } from "node:path";
 import { masterFile, masterReport } from "../loudness/loudnorm.js";
 import { cardsAss } from "./cards.js";
-import { audioMixArgs, concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips, } from "./ffmpeg.js";
+import { cacheKey, fileIdentity, keepClip, pruneClips, reuseClip } from "./clip-cache.js";
+import { audioMixArgs, burnPartArgs, concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips, } from "./ffmpeg.js";
 import { cardsIn } from "./look.js";
+import { inPool, renderJobs } from "./pool.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;
+// floor: a burned-in part shorter than a minute is not worth its own run.
+const leastPartFrames = 60 * 30;
 // The sound the join plays, as the join itself brings every segment to it.
 const masterFormat = { sampleRate: 44100, channels: 2 };
 // What the master measured, when the run asked for one.
@@ -19,7 +23,11 @@ export async function renderSlideshow(run) {
     // 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.frames), 0);
-    const work = clipMs * clipWeight + joinMs * (run.burnSubtitles ? 1 : copyWeight);
+    const jobs = run.jobs ?? renderJobs();
+    const parts = run.burnSubtitles ? burnParts(order, clips, jobs) : [];
+    const work = clipMs * clipWeight +
+        joinMs * (run.burnSubtitles ? 1 : copyWeight) +
+        (parts.length > 1 ? joinMs * copyWeight : 0);
     const report = (done) => {
         run.onProgress(work > 0 ? Math.round((Math.min(done, work) / work) * totalMs) : 0);
     };
@@ -34,66 +42,213 @@ export async function renderSlideshow(run) {
             mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
             copyFileSync(font.path, join(workspace, "fonts", `card${extname(font.path)}`));
         }
+        // The sound is mixed, levelled and encoded while the picture renders, on its own run; the
+        // join then only copies it in. Either failing stops the other, and the first failure is
+        // the one reported.
+        const stop = new AbortController();
+        const follow = () => {
+            stop.abort();
+        };
+        if (run.signal.aborted)
+            stop.abort();
+        else
+            run.signal.addEventListener("abort", follow, { once: true });
+        let failed;
+        const watched = (work) => work.catch((error) => {
+            failed ??= { error };
+            stop.abort();
+            throw error;
+        });
+        const sounding = edit.audio.length > 0
+            ? watched(renderSound(run, edit, workspace, stop.signal))
+            : Promise.resolve(undefined);
+        // Handled now, since the picture is awaited first and the sound may fail meanwhile.
+        sounding.catch(() => { });
         let rendered = 0;
-        for (const clip of clips) {
-            const before = rendered;
-            const script = clip.name.replace(/\.mp4$/, ".ass");
-            const shown = cardsIn(cards, clip.segment.start, clip.segment.count);
-            if (shown.length > 0 && font !== undefined)
-                writeFileSync(join(workspace, script), cardsAss(edit, shown, font.name, clip.segment.start, edit.cardColor), { mode: 0o600 });
-            await runFfmpeg({
-                bin: run.bin,
-                ...(cards.length > 0 ? { cwd: workspace } : {}),
-                args: segmentArgs(edit, clip.segment, join(workspace, clip.name), run.burnSubtitles, script),
-                signal: run.signal,
-                log: run.log,
-                onProgress: (elapsedMs) => report(before + elapsedMs * clipWeight),
-            });
-            rendered += msOf(clip.frames) * clipWeight;
-        }
-        const list = join(workspace, "slides.ffconcat");
-        writeFileSync(list, concatList(order), { mode: 0o600 });
-        // Level the volume: the sound, with its bed, is mixed alone and mastered first, and the join
-        // plays that one file.
-        let joined = edit;
-        let master;
-        if (run.master !== undefined && edit.audio.length > 0) {
-            const mixed = join(workspace, "mix.wav");
-            await runFfmpeg({
-                bin: run.bin,
-                args: audioMixArgs(edit, mixed),
-                signal: run.signal,
-                log: run.log,
-                onProgress: () => { },
-            });
-            const mastered = join(workspace, "master.wav");
-            await masterFile(run, mixed, mastered, run.master, masterFormat);
-            joined = {
-                ...edit,
-                audio: [
-                    {
-                        kind: "body",
-                        path: mastered,
-                        seconds: edit.audio.reduce((sum, segment) => sum + segment.seconds, 0),
+        const keys = new Set();
+        const picture = async (halt) => {
+            // Each run's own progress, summed: runs side by side each report their own elapsed time.
+            const running = new Map();
+            const tell = () => {
+                report(rendered + [...running.values()].reduce((sum, one) => sum + one, 0));
+            };
+            await inPool(clips, jobs, halt, async (clip, signal) => {
+                const script = clip.name.replace(/\.mp4$/, ".ass");
+                const shown = cardsIn(cards, clip.segment.start, clip.segment.count);
+                const drawn = shown.length > 0 && font !== undefined
+                    ? cardsAss(edit, shown, font.name, clip.segment.start, edit.cardColor)
+                    : undefined;
+                if (drawn !== undefined)
+                    writeFileSync(join(workspace, script), drawn, { mode: 0o600 });
+                const output = join(workspace, clip.name);
+                const args = segmentArgs(edit, clip.segment, output, run.burnSubtitles, script);
+                const weight = msOf(clip.frames) * clipWeight;
+                const cache = run.cache;
+                let key;
+                // The cache only saves time: a clip it cannot name or give back (another project's render
+                // let it go a moment ago) is encoded as if there were none.
+                try {
+                    if (cache !== undefined) {
+                        key = cacheKey(run.bin, args.map((value) => drawn === undefined ? value : value.replaceAll(script, "\u0000cards")), output, drawn === undefined || font === undefined ? [] : [drawn, fileIdentity(font.path)]);
+                        keys.add(key);
+                        if (reuseClip(cache, key, output)) {
+                            rendered += weight;
+                            tell();
+                            return;
+                        }
+                    }
+                }
+                catch (error) {
+                    run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                    rmSync(output, { force: true });
+                }
+                await runFfmpeg({
+                    bin: run.bin,
+                    ...(cards.length > 0 ? { cwd: workspace } : {}),
+                    args,
+                    signal,
+                    log: run.log,
+                    onProgress: (elapsedMs) => {
+                        running.set(clip.name, Math.min(elapsedMs * clipWeight, weight));
+                        tell();
                     },
-                ],
-                bed: undefined,
+                });
+                running.delete(clip.name);
+                rendered += weight;
+                if (cache !== undefined && key !== undefined) {
+                    try {
+                        keepClip(cache, key, output);
+                    }
+                    catch (error) {
+                        run.log.write("warn", "video.cache", { detail: messageOf(error) });
+                    }
+                }
+            });
+            const list = join(workspace, "slides.ffconcat");
+            writeFileSync(list, concatList(order), { mode: 0o600 });
+            if (parts.length <= 1)
+                return list;
+            // A long video's captions are burned in parts side by side, and the parts joined by
+            // copying, as the clips are without captions.
+            const done = new Map();
+            const burned = () => {
+                report(rendered + [...done.values()].reduce((sum, one) => sum + one, 0));
             };
-        }
+            await inPool(parts, jobs, halt, async (part, signal) => {
+                const partList = join(workspace, `${part.name}.ffconcat`);
+                writeFileSync(partList, concatList(part.names), { mode: 0o600 });
+                await runFfmpeg({
+                    bin: run.bin,
+                    cwd: run.cwd,
+                    args: burnPartArgs(edit, partList, join(workspace, `${part.name}.mp4`), part.start, run.portraits),
+                    signal,
+                    log: run.log,
+                    onProgress: (elapsedMs) => {
+                        done.set(part.name, Math.min(elapsedMs, msOf(part.frames)));
+                        burned();
+                    },
+                });
+                done.set(part.name, msOf(part.frames));
+                burned();
+            });
+            rendered += joinMs;
+            const joinedList = join(workspace, "parts.ffconcat");
+            writeFileSync(joinedList, concatList(parts.map((part) => `${part.name}.mp4`)), {
+                mode: 0o600,
+            });
+            return joinedList;
+        };
+        const played = await watched(picture(stop.signal)).catch(() => undefined);
+        const sound = await sounding.catch(() => undefined);
+        run.signal.removeEventListener("abort", follow);
+        if (failed !== undefined)
+            throw failed.error;
+        if (played === undefined)
+            throw new Error("the render was canceled");
+        const burnsHere = run.burnSubtitles && parts.length <= 1;
         await runFfmpeg({
             bin: run.bin,
             cwd: run.cwd,
-            args: joinArgs(joined, run.output, list, run.burnSubtitles, run.portraits),
+            args: joinArgs(edit, run.output, played, burnsHere, run.portraits, sound),
             signal: run.signal,
             log: run.log,
-            onProgress: (elapsedMs) => report(rendered + elapsedMs * (run.burnSubtitles ? 1 : copyWeight)),
+            onProgress: (elapsedMs) => report(rendered + elapsedMs * (burnsHere ? 1 : copyWeight)),
         });
+        if (run.cache !== undefined) {
+            try {
+                pruneClips(run.cache, keys);
+            }
+            catch (error) {
+                run.log.write("warn", "video.cache", { detail: messageOf(error) });
+            }
+        }
         // What the finished video measures, after its AAC encode.
-        if (run.master !== undefined && edit.audio.length > 0)
-            master = await masterReport(run, run.output, run.master);
-        return master;
+        return run.master !== undefined && edit.audio.length > 0
+            ? await masterReport(run, run.output, run.master)
+            : undefined;
     }
     finally {
         rmSync(workspace, { recursive: true, force: true });
     }
 }
+// The video's finished sound as AAC in the working folder: the narration, silences and bed
+// mixed, and with Level the volume mastered first, alone and then as one file.
+async function renderSound(run, edit, workspace, signal) {
+    const quiet = { bin: run.bin, signal, log: run.log, onProgress: () => { } };
+    let played = edit;
+    if (run.master !== undefined) {
+        const mixed = join(workspace, "mix.wav");
+        await runFfmpeg({ ...quiet, args: audioMixArgs(edit, mixed) });
+        const mastered = join(workspace, "master.wav");
+        await masterFile({ ...run, signal }, mixed, mastered, run.master, masterFormat);
+        played = {
+            ...edit,
+            audio: [
+                {
+                    kind: "body",
+                    path: mastered,
+                    seconds: edit.audio.reduce((sum, segment) => sum + segment.seconds, 0),
+                },
+            ],
+            bed: undefined,
+        };
+    }
+    const sound = join(workspace, "sound.m4a");
+    await runFfmpeg({ ...quiet, args: audioMixArgs(played, sound, "aac") });
+    return sound;
+}
+// The timeline cut at clip boundaries into at most `jobs` parts of about equal length, a
+// minute or more each; one part means the captions are burned in the join as before.
+export function burnParts(order, clips, jobs) {
+    const framesOf = new Map(clips.map((clip) => [clip.name, clip.frames]));
+    const total = order.reduce((sum, name) => sum + (framesOf.get(name) ?? 0), 0);
+    const count = Math.max(1, Math.min(jobs, Math.floor(total / leastPartFrames)));
+    const parts = [];
+    let names = [];
+    let start = 0;
+    let at = 0;
+    for (const name of order) {
+        const frames = framesOf.get(name) ?? 0;
+        const target = (total * (parts.length + 1)) / count;
+        const last = parts.length === count - 1;
+        // A part ends at the clip boundary nearest its share of the timeline.
+        if (!last && names.length > 0 && at + frames >= target && target - at < at + frames - target) {
+            parts.push({ name: `p${String(parts.length + 1)}`, names, start, frames: at - start });
+            names = [];
+            start = at;
+        }
+        names.push(name);
+        at += frames;
+        if (parts.length < count - 1 && at >= (total * (parts.length + 1)) / count) {
+            parts.push({ name: `p${String(parts.length + 1)}`, names, start, frames: at - start });
+            names = [];
+            start = at;
+        }
+    }
+    if (names.length > 0)
+        parts.push({ name: `p${String(parts.length + 1)}`, names, start, frames: at - start });
+    return parts;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}