@gentbajko/slopify 2.3.1 → 2.5.0

package/dist/slices/video/plan.js

@@ -1,5 +1,9 @@
+import { chapterCuts, narrationShotFrames } from "./cuts.js";
 import { editListVersion, } from "./edit-list.js";
+import { chapterCardSeconds } from "./edit-settings.js";
+import { hasLook } from "./look.js";
 import { motionFor } from "./motion.js";
+import { withTransitions } from "./transitions.js";
 // 30 fps, 1920×1080 for 16:9 and 1080×1920 for 9:16.
 export const fps = 30;
 const frames = {
@@ -39,6 +43,22 @@ export function planRender(input) {
         ? input.images.length * input.imageSeconds
         : audio.reduce((sum, segment) => sum + segment.seconds, 0);
     const totalFrames = Math.max(1, Math.round(totalSeconds * fps));
+    const edit = input.edit;
+    const narration = input.body === undefined ? undefined : edit?.narration;
+    const lengths = narration === undefined
+        ? everyLengths(Math.max(1, Math.round(input.imageSeconds * fps)), totalFrames)
+        : narrationShotFrames({
+            totalFrames,
+            fps,
+            imageSeconds: input.imageSeconds,
+            cutPoints: narration.cutPoints,
+            chapterStarts: narration.chapterStarts,
+        });
+    const planned = shots(input, lengths);
+    const transition = edit?.transition;
+    const cards = edit?.cards === undefined
+        ? []
+        : chapterCards(edit.cards.chapters, narration?.cutPoints ?? [], totalFrames);
     return {
         gapSeconds: input.gapSeconds,
         edgeSeconds: input.edgeSeconds,
@@ -51,13 +71,39 @@ export function planRender(input) {
             height: frame.height,
             fps,
             audio,
-            shots: shots(input, Math.max(1, Math.round(input.imageSeconds * fps)), totalFrames),
+            shots: transition === undefined
+                ? planned
+                : withTransitions(planned, transition.kind, Math.round(transition.seconds * fps)),
+            ...(edit?.look !== undefined && hasLook(edit.look) ? { look: edit.look } : {}),
+            ...(cards.length > 0 && edit?.cards !== undefined
+                ? { cards, cardFont: edit.cards.font }
+                : {}),
         },
         totalFrames,
         totalSeconds,
         output: input.output,
     };
 }
+// A card at each chapter start, on the cut the chapter's shot starts with (a chapter at the
+// very start stays there), for 2.5 s or what is left of the video.
+function chapterCards(chapters, cutPoints, totalFrames) {
+    const length = Math.round(chapterCardSeconds * fps);
+    const cards = [];
+    for (const chapter of chapters) {
+        const title = chapter.title.trim();
+        const moved = chapter.start < 1 / fps ? [] : chapterCuts([chapter.start], cutPoints, Infinity);
+        const startFrame = Math.max(0, Math.round((moved[0] ?? chapter.start) * fps));
+        const frames = Math.min(length, totalFrames - startFrame);
+        if (title === "" || frames < 1)
+            continue;
+        // Two chapters inside 2.5 s would stack their cards; the second is left out.
+        const previous = cards.at(-1);
+        if (previous !== undefined && startFrame < previous.startFrame + previous.frames)
+            continue;
+        cards.push({ title, startFrame, frames });
+    }
+    return cards;
+}
 export function spoken(kind) {
     return kind !== "gap" && kind !== "edge";
 }
@@ -92,15 +138,26 @@ export function audioTimeline(input, minimumGap = 1 / fps) {
     }
     return segments;
 }
-// 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) {
+// Every N seconds: each shot `each` frames until the timeline is full; the last shot is cut
+// to what is left. A timeline shorter than one shot is a single shot.
+function everyLengths(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),
-    }));
+    return Array.from({ length: count }, (_value, at) => Math.min(each, totalFrames - each * at));
+}
+// The images take turns in slideshow order, one per shot, starting over after the last until
+// the timeline is full. The motion goes by the shot's place, not the image (`motion.ts`), so
+// an image that comes round again may move another way. A moving clip in an image's place
+// plays as it is, with no motion of its own.
+function shots(input, lengths) {
+    return lengths.map((frames, at) => {
+        const index = at % input.images.length;
+        const clip = input.edit?.clips?.[index];
+        return clip === undefined
+            ? {
+                source: { kind: "image", path: input.images[index] ?? "" },
+                frames,
+                motion: motionFor(input.motionStyle, at, input.zoomPercent),
+            }
+            : { source: clip, frames, motion: { kind: "still" } };
+    });
 }

package/dist/slices/video/slideshow.js

@@ -1,6 +1,8 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { clipArgs, concatList, joinArgs, runFfmpeg, slideshowClips } from "./ffmpeg.js";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { cardsAss } from "./cards.js";
+import { concatList, joinArgs, runFfmpeg, segmentArgs, slideshowClips } from "./ffmpeg.js";
+import { cardsIn } from "./look.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;
@@ -12,24 +14,38 @@ export async function renderSlideshow(run) {
     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 clipMs = clips.reduce((sum, clip) => sum + msOf(clip.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 {
+        // Chapter cards are drawn by the clips from a script and a font beside them.
+        const cards = edit.cards ?? [];
+        const font = edit.cardFont;
+        if (cards.length > 0) {
+            if (font === undefined)
+                throw new Error("Slopify hit an internal error (the chapter cards have no font). Use Re-run section on Video; if it happens again, use Download diagnostics in Settings and report it.");
+            mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
+            copyFileSync(font.path, join(workspace, "fonts", `card${extname(font.path)}`));
+        }
         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), { mode: 0o600 });
             await runFfmpeg({
                 bin: run.bin,
-                args: clipArgs(edit, clip.shot, join(workspace, clip.name), run.burnSubtitles),
+                ...(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.shot.frames) * clipWeight;
+            rendered += msOf(clip.frames) * clipWeight;
         }
         const list = join(workspace, "slides.ffconcat");
         writeFileSync(list, concatList(order), { mode: 0o600 });

package/dist/slices/video/transitions.js

@@ -0,0 +1,51 @@
+// Transitions without a longer render. The slideshow is still encoded clip by clip and
+// joined by the concat demuxer (`ffmpeg.ts`); a transition is one more short clip between
+// two shots. The shot before gives up its last floor(T / 2) frames and the shot after its
+// first ceil(T / 2), and the T-frame transition clip plays the first shot's picture from
+// where it was cut, running on past its end, blended into the second's from half a
+// transition before its start. Every frame of the timeline is still played exactly once, so
+// the video stays as long as its sound.
+// The frames a transition of `frames` takes from the shot before and the shot after.
+export function transitionHalves(frames) {
+    const tail = Math.floor(frames / 2);
+    return { tail, head: frames - tail };
+}
+// Gives every shot after the first a transition of `frames` frames, shortened where a shot is
+// too short to give up its share and still show at least one frame of its own, and left a
+// hard cut where under two frames would remain.
+export function withTransitions(shots, kind, frames) {
+    return shots.map((shot, index) => {
+        const before = shots[index - 1];
+        if (before === undefined)
+            return shot;
+        const room = Math.floor((Math.min(before.frames, shot.frames) - 1) / 2);
+        const length = Math.min(Math.round(frames), room);
+        return length < 2 ? shot : { ...shot, transition: { kind, frames: length } };
+    });
+}
+// The clips in timeline order, adding up to the shots' frames exactly.
+export function segments(shots) {
+    const out = [];
+    let start = 0;
+    for (const [index, shot] of shots.entries()) {
+        const entering = shot.transition;
+        const leaving = shots[index + 1]?.transition;
+        const head = entering === undefined ? 0 : transitionHalves(entering.frames).head;
+        const tail = leaving === undefined ? 0 : transitionHalves(leaving.frames).tail;
+        if (entering !== undefined) {
+            const before = transitionHalves(entering.frames).tail;
+            out.push({
+                kind: "transition",
+                from: index - 1,
+                to: index,
+                count: entering.frames,
+                start: start - before,
+            });
+            start += head;
+        }
+        const count = shot.frames - head - tail;
+        out.push({ kind: "shot", shot: index, from: head, count, start });
+        start += count + tail;
+    }
+    return out;
+}

package/dist/slices/youtube/transcript.js

@@ -45,3 +45,57 @@ export function transcriptText(passages) {
         .map((passage) => `[${youtubeTimestamp(passage.start)}] ${passage.text}`)
         .join("\n");
 }
+// ceiling: a sentence with no full stop in 30 s (a list read out, a transcript without
+// punctuation) is closed there, so no single number spans more than a short can hold.
+const sentenceLongestSeconds = 30;
+// The narration as numbered sentences, for the Shorts step: the model picks clips by
+// sentence number and Slopify cuts at the sentences' own word times, so a clip never starts
+// or ends mid-word. A sentence closes at its full stop, question or exclamation mark, at a
+// pause of 1.5 s (the gap between intro, body and outro), or after 30 s.
+export function transcriptSentences(words) {
+    const sentences = [];
+    let first = -1;
+    const flush = (last) => {
+        if (first < 0 || last < first)
+            return;
+        const span = words.slice(first, last + 1);
+        const text = span
+            .map((word) => word.text.replace(/\s+/g, " ").trim())
+            .filter((one) => one !== "")
+            .join(" ");
+        const opening = span[0];
+        const closing = span.at(-1);
+        if (text !== "" && opening !== undefined && closing !== undefined)
+            sentences.push({
+                number: sentences.length + 1,
+                start: opening.start,
+                end: closing.end,
+                text,
+                firstWord: first,
+                lastWord: last,
+            });
+        first = -1;
+    };
+    for (const [index, word] of words.entries()) {
+        const previous = words[index - 1];
+        const opening = first < 0 ? undefined : words[first];
+        if (opening !== undefined &&
+            previous !== undefined &&
+            (word.start - previous.end >= pauseSeconds ||
+                word.end - opening.start > sentenceLongestSeconds))
+            flush(index - 1);
+        if (first < 0)
+            first = index;
+        if (/[.!?]["'’”)]*$/.test(word.text.trim()))
+            flush(index);
+    }
+    flush(words.length - 1);
+    return sentences;
+}
+// One sentence per line, led by its number and its span in the video, which is what the
+// model picks from.
+export function sentencesText(sentences) {
+    return sentences
+        .map((sentence) => `[${String(sentence.number)}] (${youtubeTimestamp(sentence.start)}-${youtubeTimestamp(sentence.end)}) ${sentence.text}`)
+        .join("\n");
+}