rvlib-shipkit 2.2.0 → 2.4.0

package/src/trailer/states.ts

@@ -0,0 +1,76 @@
+// what each frame of a take holds that a cut must not land on (wiki build/trailer.md, Film lines): a film command may
+// print `states <rle>`, each run of one state and its frames (`dialog*12,-*30`, `-` a plain frame, parts joined by `+`).
+// The stamp keeps it; the timeline names a shot whose edges cut into a change. Pure: no page, no file
+
+/** a frame with nothing on it a cut must mind */
+export const FREE = '-'
+
+/** `dialog*12,-*30`: each run of one state and its length */
+export function encodeStates(states: readonly string[]): string {
+    const runs: string[] = []
+    let i = 0
+    while (i < states.length) {
+        let j = i
+        while (j < states.length && states[j] === states[i]) j++
+        runs.push(`${states[i]}*${j - i}`)
+        i = j
+    }
+    return runs.join(',')
+}
+
+export function decodeStates(text: string): string[] {
+    const out: string[] = []
+    for (const run of text.split(',').filter(Boolean)) {
+        const at = run.lastIndexOf('*')
+        const n = Number(run.slice(at + 1))
+        if (at <= 0 || !Number.isInteger(n) || n < 1) throw new Error(`states: ${run} is no <state>*<frames>`)
+        for (let k = 0; k < n; k++) out.push(run.slice(0, at))
+    }
+    return out
+}
+
+/** the states a film's output says, its `states <rle>` word (on its own line or after ` · `); null when it says none */
+export function statesOf(said: string): string | null {
+    return /(?:^|\s·\s|\n)states (\S+)/.exec(said)?.[1] ?? null
+}
+
+/** frames at each edge of a shot where a change shows: a box rising or a change still playing reads as a flash */
+export const EDGE_FRAMES = 6
+
+export interface StatesRule {
+    /** parts that open on their own way in, never a change a cut minds */
+    ignore?: readonly string[]
+    /** parts that are a change under way: a shot never opens or ends on one */
+    underWay?: readonly string[]
+}
+
+/** what changes within EDGE_FRAMES of the shot's first or last frame (`first`, `last`: frames of the take), and a change
+ *  under way the shot opens or ends on: one line each, none when the edges are settled */
+export function edgeChanges(states: readonly string[], first: number, last: number, rule: StatesRule = {}): string[] {
+    const ignore = new Set(rule.ignore ?? [])
+    const parts = (s: string): string[] => (s === FREE ? [] : s.split('+').filter((x) => !ignore.has(x)))
+    const change = (from: string, to: string): string => {
+        const a = parts(from)
+        const b = parts(to)
+        return [...b.filter((x) => !a.includes(x)).map((x) => `${x} in`), ...a.filter((x) => !b.includes(x)).map((x) => `${x} out`)].join(', ')
+    }
+    const end = Math.min(last, states.length - 1)
+    if (first > end || first < 0) return []
+    const out: string[] = []
+    const seen = new Set<number>()
+    const at = (i: number): void => {
+        if (seen.has(i)) return
+        seen.add(i)
+        const after = i - first
+        const before = end - i + 1
+        out.push(`${change(states[i - 1]!, states[i]!)} ${after <= before ? `${after} frame${after === 1 ? '' : 's'} after its start` : `${before} frame${before === 1 ? '' : 's'} before its end`}`)
+    }
+    const moved = (i: number): boolean => change(states[i - 1]!, states[i]!) !== ''
+    for (let i = first + 1; i <= Math.min(end, first + EDGE_FRAMES); i++) if (moved(i)) at(i)
+    for (let i = Math.max(first + 1, end - EDGE_FRAMES + 1); i <= end; i++) if (moved(i)) at(i)
+    for (const u of rule.underWay ?? []) {
+        if (parts(states[first]!).includes(u)) out.unshift(`opens on a ${u}`)
+        if (end > first && parts(states[end]!).includes(u)) out.push(`ends on a ${u}`)
+    }
+    return out
+}

package/src/trailer/stitch.ts

@@ -5,8 +5,9 @@ import { existsSync, mkdirSync, renameSync, rmSync, statSync, utimesSync, writeF
 import { availableParallelism } from 'node:os'
 import { dirname, join } from 'node:path'
 import sharp from 'sharp'
-import { ffmpeg } from './ffmpeg.ts'
-import { type Encoder, mixArgs, pieceArgs, type StitchInput, THUMB_W } from './graph.ts'
+import { ffmpeg, loudnessKept } from './ffmpeg.ts'
+import { type Encoder, GRID_RADIUS, gridLayout, MIX_TRUE_PEAK, mixArgs, pieceArgs, type SplitMasks, splitPane, type StitchInput, THUMB_W } from './graph.ts'
+import type { TrailerLook } from './look.ts'
 import { type Piece, pieces } from './plan.ts'
 
 /** bump when the stitch changes what the same arguments make */
@@ -50,6 +51,67 @@ export async function cachedAs(dir: string, stem: string, key: string, exts: str
     return { files, made: true }
 }
 
+const n3 = (x: number): string => (+x.toFixed(4)).toString()
+
+/** a drawing's own temporary file beside `file`: two builds drawing one piece at once each rename their own */
+const partOf = (file: string): string => `${file}.${process.pid}-${Math.random().toString(36).slice(2, 8)}.part.png`
+
+async function drawSvg(file: string, svg: string): Promise<void> {
+    mkdirSync(dirname(file), { recursive: true })
+    const part = partOf(file)
+    await sharp(Buffer.from(svg)).png().toFile(part)
+    renameSync(part, file)
+}
+
+const colourKey = (look: Pick<TrailerLook, 'ground' | 'light' | 'edge'>): string => new Bun.CryptoHasher('sha1').update(JSON.stringify([look.ground, look.light, look.edge])).digest('hex').slice(0, 8)
+
+/** a grid's frame for `n` cells: the look's ground with a hole per cell, its corners rounded and rimmed in its light;
+ *  laid over the cells. Drawn once per layout and look and kept, so its file never changes a piece's key */
+export async function gridMask(dir: string, n: number, size: readonly [number, number], look: Pick<TrailerLook, 'ground' | 'light' | 'edge'>): Promise<string> {
+    const [W, H] = size
+    const file = join(dir, 'grid', `mask-${STITCH_VERSION}-${n}-${W}x${H}-${colourKey(look)}.png`)
+    if (existsSync(file)) return file
+    const r = H * GRID_RADIUS
+    const rim = Math.max(1.5, H * 0.0028)
+    const cells = gridLayout(n, W, H)
+    const holes = cells.map((c) => `<rect x="${c.x}" y="${c.y}" width="${c.w}" height="${c.h}" rx="${n3(r)}" fill="black"/>`).join('')
+    const rims = cells.map((c) => `<rect x="${c.x + rim / 2}" y="${c.y + rim / 2}" width="${c.w - rim}" height="${c.h - rim}" rx="${n3(r - rim / 2)}" fill="none" stroke="${look.light}" stroke-opacity="0.85" stroke-width="${n3(rim)}"/>`).join('')
+    await drawSvg(
+        file,
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}">
+<defs><radialGradient id="g" cx="50%" cy="45%" r="75%"><stop offset="0" stop-color="${look.ground[0]}"/><stop offset="1" stop-color="${look.ground[1]}"/></radialGradient>
+<mask id="m"><rect width="${W}" height="${H}" fill="white"/>${holes}</mask></defs>
+<rect width="${W}" height="${H}" fill="url(#g)" mask="url(#m)"/>${rims}</svg>`,
+    )
+    return file
+}
+
+/** a split's panes and seams for `n` panes at `angle`: each pane's shape, and the seams, a line of the look's light over
+ *  a soft shadow of its edge, its width a 150th of the frame's height. Drawn once and kept like the grid's frame */
+export async function splitMasks(dir: string, n: number, angle: number, size: readonly [number, number], look: Pick<TrailerLook, 'ground' | 'light' | 'edge'>): Promise<SplitMasks> {
+    const [W, H] = size
+    const stem = join(dir, 'split', `${STITCH_VERSION}-${n}-${n3(angle)}-${W}x${H}`)
+    const panes = Array.from({ length: n }, (_, j) => `${stem}-pane${j}.png`)
+    const seams = `${stem}-seams-${colourKey(look)}.png`
+    if ([...panes, seams].every((f) => existsSync(f))) return { panes, seams }
+    const poly = (pts: [number, number][]): string => pts.map(([x, y]) => `${n3(x)},${n3(y)}`).join(' ')
+    for (let j = 0; j < n; j++)
+        if (!existsSync(panes[j]!))
+            await drawSvg(panes[j]!, `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}"><rect width="${W}" height="${H}" fill="black"/><polygon points="${poly(splitPane(n, j, angle, W, H).points)}" fill="white"/></svg>`)
+    const t = Math.tan((angle * Math.PI) / 180)
+    // each seam drawn from well above the frame to well below it, so it crosses it whole
+    const lines = Array.from({ length: n - 1 }, (_, i) => (W * (i + 1)) / n)
+    const wLine = Math.max(2, H / 150)
+    const seg = (stroke: string, width: number): string =>
+        lines.map((x) => `<line x1="${n3(x + 1.5 * H * t)}" y1="${-H}" x2="${n3(x - 1.5 * H * t)}" y2="${2 * H}" stroke="${stroke}" stroke-width="${n3(width)}"/>`).join('')
+    await drawSvg(
+        seams,
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}"><defs><filter id="s" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="${n3(H / 90)}"/></filter></defs>` +
+            `<g filter="url(#s)" opacity="0.55">${seg(look.edge, wLine * 4)}</g>${seg(look.light, wLine)}</svg>`,
+    )
+    return { panes, seams }
+}
+
 /** runs the jobs, at most `n` at once */
 export async function pool<T>(jobs: (() => Promise<T>)[], n: number): Promise<T[]> {
     const out: T[] = []
@@ -95,19 +157,31 @@ async function renderPieces(a: StitchRun, ps: Piece[]): Promise<Stitched['pieces
     )
 }
 
-async function renderMix(a: StitchRun): Promise<{ file: string; made: boolean }> {
-    const { files, made } = await cached(join(a.cache, 'mix'), `mix-${a.t.name}`, ['m4a'], ([out]) => mixArgs(a, out!))
-    return { file: files[0]!, made }
+/** the mix, its true peak held under MIX_TRUE_PEAK after the aac encode: the encoder's band limit rings over a limited
+ *  harsh sound (a square wave measured +2.1 dB), so a mix that overshoots is made again that much lower */
+export async function renderMix(a: Pick<StitchRun, 't' | 'music' | 'sfx' | 'voices' | 'cache'>): Promise<{ file: string; made: boolean }> {
+    let trim = 0
+    let made = false
+    for (let pass = 0; ; pass++) {
+        const r = await cached(join(a.cache, 'mix'), `mix-${a.t.name}`, ['m4a'], ([out]) => mixArgs(a, out!, trim))
+        made ||= r.made
+        const { truePeak } = await loudnessKept(r.files[0]!)
+        if (truePeak <= MIX_TRUE_PEAK || pass === 2) return { file: r.files[0]!, made }
+        trim = +(trim - (truePeak - MIX_TRUE_PEAK) - 0.1).toFixed(2)
+    }
 }
 
-/** the pieces joined as they are, no encode, with the sound beside them */
-async function joinPieces(files: string[], sound: string | null, out: string): Promise<void> {
+/** the pieces joined as they are, no encode, with the sound beside them: the whole mix copied, or a window of it (a
+ *  section alone) cut on its samples, so encoded again */
+async function joinPieces(files: string[], sound: { file: string; start?: number; seconds?: number } | null, out: string): Promise<void> {
     mkdirSync(dirname(out), { recursive: true })
     const list = `${out}.list.txt`
     writeFileSync(list, files.map((f) => `file '${f.replaceAll("'", "'\\''")}'`).join('\n'))
     const part = out.replace(/(\.\w+)$/, '.part$1')
+    const audio = sound ? [...(sound.start !== undefined ? ['-ss', n3(sound.start), '-t', n3(sound.seconds ?? 0)] : []), '-i', sound.file] : []
+    const acodec = sound?.start !== undefined ? ['-c:a', 'aac', '-b:a', '192k'] : ['-c:a', 'copy']
     try {
-        await ffmpeg(['-f', 'concat', '-safe', '0', '-i', list, ...(sound ? ['-i', sound] : []), '-map', '0:v', ...(sound ? ['-map', '1:a', '-c:a', 'copy'] : []), '-c:v', 'copy', '-movflags', '+faststart', part], { nice: 10 })
+        await ffmpeg(['-f', 'concat', '-safe', '0', '-i', list, ...audio, '-map', '0:v', ...(sound ? ['-map', '1:a', ...acodec] : []), '-c:v', 'copy', '-movflags', '+faststart', part], { nice: 10 })
         renameSync(part, out)
     } finally {
         rmSync(list, { force: true })
@@ -118,7 +192,16 @@ async function joinPieces(files: string[], sound: string | null, out: string): P
 /** the whole cut: every piece (rendered where the cache misses it), joined, with its sound */
 export async function stitch(a: StitchRun): Promise<Stitched> {
     const [ps, mix] = await Promise.all([renderPieces(a, pieces(a.t)), a.silent ? null : renderMix(a)])
-    await joinPieces(ps.map((p) => p.file), mix?.file ?? null, a.out)
+    await joinPieces(ps.map((p) => p.file), mix ? { file: mix.file } : null, a.out)
+    return { pieces: ps, mixed: mix?.made ?? false, mix: mix?.file ?? null }
+}
+
+/** one piece alone (a section, `start` the shots before the first), with its window of the sound */
+export async function stitchPiece(a: StitchRun, name: string): Promise<Stitched> {
+    const p = pieces(a.t).find((x) => x.name === name)
+    if (!p) throw new Error(`no section ${name}: ${pieces(a.t).map((x) => x.name).join(', ')}`)
+    const [ps, mix] = await Promise.all([renderPieces(a, [p]), a.silent ? null : renderMix(a)])
+    await joinPieces(ps.map((x) => x.file), mix && { file: mix.file, start: p.from / a.t.fps, seconds: (p.to - p.from) / a.t.fps }, a.out)
     return { pieces: ps, mixed: mix?.made ?? false, mix: mix?.file ?? null }
 }