@@ -159,8 +159,31 @@
Export
+
+
+
+
WebCodecs has no CRF — quality is driven by bitrate. VBR spends bits on hard frames; CBR holds a steady rate.
+
diff --git a/ruler-worker.js b/ruler-worker.js
index 33b5af7..2c16475 100644
--- a/ruler-worker.js
+++ b/ruler-worker.js
@@ -12,7 +12,7 @@ let cv = null, g = null;
function fmt(t, fps) {
t = Math.max(0, t);
const m = Math.floor(t / 60), s = Math.floor(t % 60),
- f = Math.floor((t % 1) * (fps || 30));
+ f = Math.floor((t % 1) * (fps > 0 ? fps : 1));
const p = (n) => String(n).padStart(2, "0");
return `${p(m)}:${p(s)}:${p(f)}`;
}
diff --git a/server.js b/server.js
index fdf7476..414d79f 100644
--- a/server.js
+++ b/server.js
@@ -144,36 +144,100 @@ async function faststart(file) {
} catch { try { fs.rmSync(tmp); } catch {} }
}
-/* ── Fast export sessions ──
- The browser renders frames with its own compositor and streams them here as
- JPEGs; ffmpeg encodes them (plus an optional WAV mix) into a real MP4. */
+/* ── Export sessions ──
+ Two modes share the same HTTP session API:
+ jpeg — browser streams JPEGs; ffmpeg encodes H.264 (Fast path)
+ annexb — browser streams Annex-B H.264 NALs; ffmpeg stream-copies (WebCodecs)
+ Annex-B is spawned lazily on the first frame so the WAV (uploaded between
+ /begin and /frame) can be included in the same one-pass mux. */
const exportSessions = new Map();
-function beginExport(fps, name) {
+const EXPORT_IDLE_MS = 10 * 60 * 1000; // abandon sessions with no successful activity
+const EXPORT_SWEEP_MS = 60 * 1000;
+let exportSweepTimer = null;
+function touchExport(sess) {
+ if (sess) sess.lastTouch = Date.now();
+}
+function attachProc(sess, proc) {
+ sess.proc = proc;
+ sess.stderr = "";
+ proc.stderr.on("data", (d) => { sess.stderr = (sess.stderr + d).slice(-2000); });
+ proc.stdin.on("error", () => {}); // EPIPE if ffmpeg dies mid-stream
+ sess.done = new Promise((res) => proc.on("close", res));
+}
+function beginExport(fps, name, mode) {
const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "fablecut-"));
- const videoPath = path.join(dir, "video.mp4");
- const proc = spawn("ffmpeg", [
- "-y", "-f", "image2pipe", "-framerate", String(fps), "-i", "-",
- "-c:v", "libx264", "-preset", "fast", "-crf", "18", "-pix_fmt", "yuv420p",
- videoPath,
- ], { stdio: ["pipe", "ignore", "pipe"] });
- let stderr = "";
- proc.stderr.on("data", (d) => { stderr = (stderr + d).slice(-2000); });
- proc.stdin.on("error", () => {}); // EPIPE if ffmpeg dies mid-stream; surfaced via exit code
+ const m = mode === "annexb" ? "annexb" : "jpeg";
+ const rate = Number(fps);
+ if (!Number.isFinite(rate) || rate <= 0) {
+ throw new Error("export fps required (pass project.fps)");
+ }
const sess = {
- proc, dir, videoPath, name: safeName(name || "export"),
- wav: null, err: () => stderr,
- done: new Promise((res) => proc.on("close", res)),
+ mode: m, fps: rate, proc: null, dir,
+ name: safeName(name || "export"),
+ videoPath: null, partPath: null, outPath: null,
+ wav: null, stderr: "", done: null, lastTouch: Date.now(),
+ err: () => sess.stderr.trim().split("\n").filter(Boolean).slice(-3)
+ .map((l) => l.trim()).join(" · "),
};
+ if (m === "jpeg") {
+ sess.videoPath = path.join(dir, "video.mp4");
+ attachProc(sess, spawn("ffmpeg", [
+ "-y", "-hide_banner", "-f", "image2pipe", "-framerate", String(sess.fps), "-i", "-",
+ "-c:v", "libx264", "-preset", "fast", "-crf", "18", "-pix_fmt", "yuv420p",
+ sess.videoPath,
+ ], { stdio: ["pipe", "ignore", "pipe"] }));
+ }
+ // serialize stdin writes — concurrent /frame handlers would race the pipe
+ sess.writeLock = Promise.resolve();
exportSessions.set(id, sess);
return id;
}
+/* One-pass mux for WebCodecs: H.264 elementary stream on stdin + optional WAV.
+ Use input `-r` (not only `-framerate`): HW encoders stamp AUs with µs-rounded
+ durations (e.g. 33333µs ≈ 1/30), which otherwise become avg_frame_rate
+ 1000000/33333. `-r` forces CFR PTS so the MP4 matches project.fps exactly. */
+function startAnnexbEncoder(sess) {
+ const base = sess.name.replace(/\.mp4$/i, "");
+ sess.outPath = uniquePath(EXPORTS_DIR, base + ".mp4");
+ // ".part" before the extension so ffmpeg can still pick the mp4 muxer
+ sess.partPath = sess.outPath.slice(0, -4) + ".part.mp4";
+ const fps = sess.fps;
+ const args = [
+ "-y", "-hide_banner",
+ "-fflags", "+genpts",
+ "-f", "h264", "-r", String(fps), "-i", "pipe:0",
+ ];
+ if (sess.wav) args.push("-i", sess.wav);
+ args.push("-map", "0:v:0", "-c:v", "copy");
+ // do not use -shortest: with unset/generated PTS it drops the audio track
+ if (sess.wav) args.push("-map", "1:a:0", "-c:a", "aac", "-b:a", "192k");
+ args.push("-movflags", "+faststart", sess.partPath);
+ attachProc(sess, spawn("ffmpeg", args, { stdio: ["pipe", "ignore", "pipe"] }));
+ return sess.proc;
+}
function cleanupExport(id) {
const s = exportSessions.get(id);
if (!s) return;
exportSessions.delete(id);
- try { s.proc.kill(); } catch {}
+ try { s.proc?.kill(); } catch {}
try { fs.rmSync(s.dir, { recursive: true, force: true }); } catch {}
+ if (s.partPath) try { fs.rmSync(s.partPath, { force: true }); } catch {}
+}
+function sweepIdleExports() {
+ const now = Date.now();
+ for (const [id, s] of [...exportSessions]) {
+ if (now - (s.lastTouch || 0) > EXPORT_IDLE_MS) cleanupExport(id);
+ }
+}
+function startExportSweep() {
+ if (exportSweepTimer) return;
+ exportSweepTimer = setInterval(sweepIdleExports, EXPORT_SWEEP_MS);
+}
+function stopExportSweep() {
+ if (!exportSweepTimer) return;
+ clearInterval(exportSweepTimer);
+ exportSweepTimer = null;
}
/* Static file with HTTP Range support (required for