NINI
110 lines
6.3 KiB
JavaScript
110 lines
6.3 KiB
JavaScript
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import {execFileSync} from 'node:child_process';
|
|
import {bundle} from '@remotion/bundler';
|
|
import {openBrowser, renderMedia, renderStill, selectComposition} from '@remotion/renderer';
|
|
import {absolute, artifact, prepareData, projectDir, rendererDir, relative, write} from './data.mjs';
|
|
|
|
const mode = process.argv[2] ?? 'preview';
|
|
if (!['preview', 'motion', 'compose'].includes(mode)) throw new Error('Use preview, motion or compose');
|
|
process.chdir(rendererDir);
|
|
const data = prepareData();
|
|
const binaries = path.join(rendererDir, 'node_modules/@remotion/compositor-win32-x64-msvc');
|
|
const ffmpeg = path.join(binaries, 'ffmpeg.exe');
|
|
const ffprobe = path.join(binaries, 'ffprobe.exe');
|
|
const execute = (args) => execFileSync(ffmpeg, ['-hide_banner', '-loglevel', 'error', '-n', ...args], {stdio: 'inherit'});
|
|
const probe = (file) => JSON.parse(execFileSync(ffprobe,
|
|
['-v', 'error', '-show_streams', '-show_format', '-of', 'json', file], {encoding: 'utf8'}));
|
|
const measured = (file, expectedMs) => {
|
|
const p = probe(file), v = p.streams.find((s) => s.codec_type === 'video');
|
|
const ms = Math.round(Number(v.duration) * 1000);
|
|
if (ms !== expectedMs || v.width !== 1080 || v.height !== 1920 || v.r_frame_rate !== '50/1') {
|
|
throw new Error(`${file}: unexpected actual duration/size/fps`);
|
|
}
|
|
return {path: relative(file), duration_ms: ms, width: v.width, height: v.height,
|
|
frames: Number(v.nb_frames), codec: v.codec_name};
|
|
};
|
|
|
|
if (mode === 'compose') {
|
|
const result = artifact('12-motion').payload.result;
|
|
if (!result || result.clips.length !== 31 || result.clips.some((c) => !c.media.verified)) {
|
|
throw new Error('31 visually verified real motion clips required before compose');
|
|
}
|
|
for (const clip of data.clips) {
|
|
const source = result.clips.find((c) => c.cut_id === clip.id).media.path;
|
|
measured(absolute(source), clip.end_ms - clip.start_ms);
|
|
fs.copyFileSync(absolute(source), path.join(rendererDir, `public/${clip.id}.mp4`));
|
|
}
|
|
}
|
|
const serveUrl = await bundle({entryPoint: path.join(rendererDir, 'Scene.jsx'),
|
|
outDir: path.join(rendererDir, 'bundle'), publicDir: path.join(rendererDir, 'public')});
|
|
const browser = await openBrowser('chrome', {logLevel: 'warn'});
|
|
const id = mode === 'compose' ? 'Composed' : 'Motion';
|
|
const inputProps = {data};
|
|
const composition = await selectComposition({serveUrl, id, inputProps, puppeteerInstance: browser});
|
|
const stage = mode === 'compose' ? '13-compose' : '12-motion';
|
|
const out = path.join(projectDir, `media/${stage}/r1`);
|
|
fs.mkdirSync(out, {recursive: true});
|
|
try {
|
|
if (mode === 'preview') {
|
|
const inspection = path.join(out, 'inspection'); fs.mkdirSync(inspection, {recursive: true});
|
|
const focus = process.argv.slice(3);
|
|
for (const clip of data.clips.filter((c) => !focus.length || focus.includes(c.id))) for (const [position, offset] of
|
|
[['start', 0], ['middle', Math.floor(clip.frames / 2)], ['end', clip.frames - 1]]) {
|
|
await renderStill({serveUrl, composition, inputProps, puppeteerInstance: browser,
|
|
frame: clip.start_ms / 20 + offset, scale: 0.5, imageFormat: 'png',
|
|
output: path.join(inspection, `${clip.id}-${position}.png`)});
|
|
}
|
|
console.log('Actual Remotion state previews rendered. Visual inspection remains required.');
|
|
} else {
|
|
const master = path.join(out, mode === 'motion' ? 'motion-master.mp4' : 'captioned-silent.mp4');
|
|
if (!fs.existsSync(master)) {
|
|
let last = -1;
|
|
await renderMedia({serveUrl, composition, inputProps, puppeteerInstance: browser,
|
|
codec: 'h264', outputLocation: master, crf: 18, x264Preset: 'fast',
|
|
pixelFormat: 'yuv420p', concurrency: 4, muted: true, overwrite: false,
|
|
onProgress: ({progress}) => {
|
|
const percent = Math.floor(progress * 20) * 5;
|
|
if (percent !== last) {console.log(`${id}: ${percent}%`); last = percent;}
|
|
}});
|
|
}
|
|
const masterMetadata = measured(master, data.duration_ms);
|
|
if (mode === 'motion') {
|
|
const clips = [];
|
|
for (const c of data.clips) {
|
|
const file = path.join(out, `${c.id}.mp4`);
|
|
if (!fs.existsSync(file)) execute(['-ss', String(c.start_ms / 1000), '-i', master,
|
|
'-an', '-frames:v', String(c.frames), '-c:v', 'libx264', '-crf', '18',
|
|
'-preset', 'fast', '-threads', '2', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', file]);
|
|
clips.push({cut_id: c.id, ...measured(file, c.end_ms - c.start_ms)});
|
|
if (clips.at(-1).frames !== c.frames) throw new Error(`${c.id} frame count mismatch`);
|
|
}
|
|
write(path.join(out, 'probe.json'), {master: masterMetadata, clips,
|
|
note: 'Technical measurements only. Playback and visual inspection are separate.'});
|
|
} else {
|
|
const narration = artifact('06-tts').payload.result.narration;
|
|
const video = path.join(out, 'surface-tension-ko.mp4');
|
|
// Copy the video and encode the already approved full WAV once, without speed/trim/gain changes.
|
|
if (!fs.existsSync(video)) execute(['-i', master, '-i', absolute(narration.path),
|
|
'-map', '0:v:0', '-map', '1:a:0', '-c:v', 'copy', '-c:a', 'aac', '-b:a', '192k',
|
|
'-movflags', '+faststart', video]);
|
|
const metadata = measured(video, data.duration_ms);
|
|
const time = (ms) => {
|
|
const hours = Math.floor(ms / 3600000), minutes = Math.floor(ms / 60000) % 60;
|
|
const seconds = Math.floor(ms / 1000) % 60;
|
|
return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')},${String(ms % 1000).padStart(3, '0')}`;
|
|
};
|
|
fs.writeFileSync(path.join(out, 'surface-tension-ko.srt'), data.captions.map((c, i) =>
|
|
`${i + 1}\n${time(c.start_ms)} --> ${time(c.end_ms)}\n${c.text}\n`).join('\n'), 'utf8');
|
|
write(path.join(out, 'probe.json'), {video: metadata, streams: probe(video).streams,
|
|
note: 'Actual file measurements. Encoded narration listening remains a user review item.'});
|
|
const inspection = path.join(out, 'inspection'); fs.mkdirSync(inspection, {recursive: true});
|
|
for (const c of data.clips) {
|
|
// Decode an actual encoded final-video frame, rather than using the request PNG as evidence.
|
|
execute(['-ss', String((c.start_ms + c.end_ms) / 2000), '-i', video, '-frames:v', '1',
|
|
'-vf', 'scale=540:960', path.join(inspection, `${c.id}-middle.png`)]);
|
|
}
|
|
}
|
|
}
|
|
} finally {await browser.close({silent: true});}
|