Skip to content

Write HTML. Render video. Built for agents.

perf(producer): multi-worker mp4 renders start encoding while frames are still being captured (#5952)

Miguel Ángeleec3c51d7509
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 26fd4571d7..36b984d745 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -295,6 +295,7 @@ export {
type WorkerResult,
type WorkerSizing,
type WorkerSizingBound,
+ type LandedFrame,
type ParallelProgress,
} from "./services/parallelCoordinator.js";
diff --git a/packages/engine/src/services/parallelCoordinator.ts b/packages/engine/src/services/parallelCoordinator.ts
index adf6699fa5..d970fa191d 100644
--- a/packages/engine/src/services/parallelCoordinator.ts
+++ b/packages/engine/src/services/parallelCoordinator.ts
@@ -88,6 +88,14 @@ export interface ParallelProgress {
workerProgress: Map<number, number>;
/** Latest lifecycle transition; absent on ordinary completed-frame updates. */
latestWorkerPhase?: ParallelWorkerPhaseDiagnostic;
+ /** Disk capture only: the frame file this update finished writing, readable from now on. */
+ landedFrame?: LandedFrame;
+}
+
+/** A captured frame file: `index` is its file index (`frame_<index>`), `path` where it was written. */
+export interface LandedFrame {
+ index: number;
+ path: string;
}
export type ParallelWorkerPhase =
@@ -552,7 +560,9 @@ async function captureFrameRange(
task: WorkerTask,
captureOptions: CaptureOptions,
signal: AbortSignal | undefined,
- onFrameCaptured: ((workerId: number, frameIndex: number) => void) | undefined,
+ onFrameCaptured:
+ | ((workerId: number, frameIndex: number, landedFrame?: LandedFrame) => void)
+ | undefined,
onFrameBuffer:
| ((frameIndex: number, buffer: Buffer, session: CaptureSession) => Promise<void>)
| undefined,
@@ -645,18 +655,20 @@ async function captureFrameRange(
const time = (i * captureOptions.fps.den) / captureOptions.fps.num;
const fileFrameIdx = i - outputOffset;
+ let landedFrame: LandedFrame | undefined;
if (onFrameBuffer) {
const { buffer } = await runCaptureOperation("frame_capture", i, () =>
captureFrameToBuffer(session, fileFrameIdx, time),
);
await onFrameBuffer(i, buffer, session);
} else {
- await runCaptureOperation("frame_capture", i, () =>
+ const { path } = await runCaptureOperation("frame_capture", i, () =>
captureFrame(session, fileFrameIdx, time),
);
+ landedFrame = { index: fileFrameIdx, path };
}
framesCaptured++;
- if (onFrameCaptured) onFrameCaptured(task.workerId, i);
+ if (onFrameCaptured) onFrameCaptured(task.workerId, i, landedFrame);
}
return framesCaptured;
}
@@ -824,7 +836,7 @@ async function executeWorkerTask(
captureOptions: CaptureOptions,
createBeforeCaptureHook: () => BeforeCaptureHook | null,
signal?: AbortSignal,
- onFrameCaptured?: (workerId: number, frameIndex: number) => void,
+ onFrameCaptured?: (workerId: number, frameIndex: number, landedFrame?: LandedFrame) => void,
onFrameBuffer?: (frameIndex: number, buffer: Buffer, session: CaptureSession) => Promise<void>,
config?: Partial<EngineConfig>,
parallel?: boolean,
@@ -1066,7 +1078,7 @@ export async function executeParallelCapture(
for (const task of tasks) workerProgress.set(task.workerId, 0);
- const onFrameCaptured = (workerId: number, _frameIndex: number) => {
+ const onFrameCaptured = (workerId: number, _frameIndex: number, landedFrame?: LandedFrame) => {
const current = workerProgress.get(workerId) || 0;
workerProgress.set(workerId, current + 1);
@@ -1077,6 +1089,7 @@ export async function executeParallelCapture(
capturedFrames,
activeWorkers: tasks.length,
workerProgress: new Map(workerProgress),
+ ...(landedFrame && { landedFrame }),
});
}
};
diff --git a/packages/producer/scripts/test-classification.mjs b/packages/producer/scripts/test-classification.mjs
index cf3937ba88..7ee13f95ca 100644
--- a/packages/producer/scripts/test-classification.mjs
+++ b/packages/producer/scripts/test-classification.mjs
@@ -37,6 +37,7 @@ const INTEGRATION_TEST_FILES = new Set([
"src/services/render/renderCancel.integration.test.ts",
"src/services/render/segmentedColorGrading.integration.test.ts",
"src/services/render/stages/compileStage.mediaType.test.ts",
+ "src/services/render/stages/encodeWhileCapturing.test.ts",
"src/services/render/stages/gifEncodeArgs.test.ts",
"src/services/videoFrameBorderClip.test.ts",
"src/utils/audioRegression.test.ts",
diff --git a/packages/producer/src/services/render/stages/captureStage.ts b/packages/producer/src/services/render/stages/captureStage.ts
index a1963b9b26..c949ec1faa 100644
--- a/packages/producer/src/services/render/stages/captureStage.ts
+++ b/packages/producer/src/services/render/stages/captureStage.ts
@@ -45,6 +45,7 @@ import {
type CapturePerfSummary,
type CaptureSession,
type EngineConfig,
+ type LandedFrame,
captureFrame,
captureFrameToBufferPipelined,
verifyDiskDrawElementSamples,
@@ -118,6 +119,7 @@ export interface CaptureStageInput {
* When set, `endFrame - startFrame` MUST equal `totalFrames`.
*/
frameRange?: { startFrame: number; endFrame: number };
+ onFrameLanded?: (frame: LandedFrame) => void;
}
export interface CaptureStageResult {
@@ -408,6 +410,7 @@ export async function runCaptureStage(input: CaptureStageInput): Promise<Capture
if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
return;
}
+ if (progress.landedFrame) input.onFrameLanded?.(progress.landedFrame);
job.framesRendered = progress.capturedFrames;
checkDiskProjection(progress.capturedFrames);
const frameProgress = progress.capturedFrames / progress.totalFrames;
diff --git a/packages/producer/src/services/render/stages/encodeStage.test.ts b/packages/producer/src/services/render/stages/encodeStage.test.ts
index 74858dab71..0469fe4303 100644
--- a/packages/producer/src/services/render/stages/encodeStage.test.ts
+++ b/packages/producer/src/services/render/stages/encodeStage.test.ts
@@ -46,6 +46,7 @@ mock.module("@hyperframes/engine", () => ({
}),
resolveConfig: () => resolvedEngineConfig,
runFfmpeg: runFfmpegMock,
+ spawnStreamingEncoder: mock(),
}));
const tempDirs: string[] = [];
diff --git a/packages/producer/src/services/render/stages/encodeStage.ts b/packages/producer/src/services/render/stages/encodeStage.ts
index 3c9465f33b..e5fda1acbc 100644
--- a/packages/producer/src/services/render/stages/encodeStage.ts
+++ b/packages/producer/src/services/render/stages/encodeStage.ts
@@ -26,6 +26,10 @@
* branch + same args.
* - `Encoding failed: <err>` throws on the encoder's
* `success: false`.
+ *
+ * `encodeWhileCapturing` runs the same mp4 encode during multi-worker disk
+ * capture, feeding frames in order as they land, and falls back to this
+ * stage's encode if it fails.
*/
import {
@@ -38,6 +42,7 @@ import {
statSync,
writeFileSync,
} from "node:fs";
+import { readFile } from "node:fs/promises";
import { dirname, join } from "node:path";
import {
encodeFramesChunkedConcat,
@@ -47,8 +52,10 @@ import {
MIXED_AUDIO_FILENAME,
resolveConfig,
runFfmpeg,
+ spawnStreamingEncoder,
type EngineConfig,
type EncodeResult,
+ type LandedFrame,
} from "@hyperframes/engine";
import {
clearGifFramesBeforeNext,
@@ -56,7 +63,7 @@ import {
type Fps,
} from "@hyperframes/core";
import type { ProducerLogger } from "../../../logger.js";
-import { formatExportFrameName } from "../../../utils/paths.js";
+import { formatCaptureFrameName, formatExportFrameName } from "../../../utils/paths.js";
import type { ProgressCallback, RenderJob } from "../../renderOrchestrator.js";
import {
buildGifPalettegenArgs,
@@ -108,7 +115,8 @@ export interface EncodeStageInput {
enableChunkedEncode: boolean;
chunkedEncodeSize: number;
/** Already-resolved engine config from the orchestrator; direct callers fall back below. */
- engineConfig?: Pick<EngineConfig, "ffmpegEncodeTimeout" | "vp9CpuUsed">;
+ engineConfig?: Pick<EngineConfig, "ffmpegEncodeTimeout" | "vp9CpuUsed"> &
+ Partial<Pick<EngineConfig, "ffmpegStreamingTimeout">>;
abortSignal: AbortSignal | undefined;
assertNotAborted: () => void;
onProgress?: ProgressCallback;
@@ -254,6 +262,171 @@ function startEncodeProgress(
return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);
}
+function resolveEngineConfig(input: EncodeStageInput) {
+ return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();
+}
+
+function videoEncoderOptions(input: EncodeStageInput, engineCfg: Pick<EngineConfig, "vp9CpuUsed">) {
+ const { job, preset } = input;
+ return {
+ fps: job.config.fps,
+ width: input.width,
+ height: input.height,
+ codec: preset.codec,
+ preset: preset.preset,
+ quality: input.effectiveQuality,
+ bitrate: input.effectiveBitrate,
+ pixelFormat: preset.pixelFormat,
+ vp9CpuUsed: engineCfg.vp9CpuUsed,
+ useGpu: job.config.useGpu,
+ hdr: preset.hdr,
+ // Distributed chunk renders pass these so the encoder writes closed-GOP
+ // keyframes that survive `-f concat -c copy` at assemble time. In-process
+ // renders leave both undefined → preserves the existing open-GOP output.
+ lockGopForChunkConcat: input.lockGopForChunkConcat === true,
+ gopSize: input.gopSize,
+ };
+}
+
+/**
+ * Software libx264 from JPEG only: the streaming encoder then runs the disk encoder's
+ * arguments (same bytes). Needs a core the capture workers leave free.
+ */
+export function canEncodeWhileCapturing(
+ input: EncodeStageInput,
+ workerCount: number,
+ cpuCount: number,
+): boolean {
+ return (
+ workerCount > 1 &&
+ workerCount < cpuCount &&
+ !input.isPngSequence &&
+ !input.isGif &&
+ !input.enableChunkedEncode &&
+ input.preset.codec === "h264" &&
+ !input.preset.hdr &&
+ input.job.config.useGpu !== true &&
+ input.captureImageFormat === "jpeg" &&
+ input.lockGopForChunkConcat !== true
+ );
+}
+
+export interface EncodeWhileCapturing {
+ /** A worker finished writing this frame. */
+ onFrameLanded: (frame: LandedFrame) => void;
+ /** Capture succeeded and every frame is in `framesDir`: encode the rest. */
+ finish: () => Promise<EncodeStageResult>;
+ /** Capture failed: stop the encoder and wait for it to exit. */
+ abort: () => Promise<void>;
+ /** Frames handed to the encoder so far. */
+ readonly framesFed: number;
+}
+
+/** The merge renames a worker's frame into `framesDir` at any moment; rename is atomic, so it is at one of the two. */
+async function readLandedFrame(workerPath: string | undefined, mergedPath: string) {
+ if (workerPath !== undefined) {
+ try {
+ return await readFile(workerPath);
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+ }
+ }
+ return readFile(mergedPath);
+}
+
+/**
+ * Feeds frames 0, 1, 2… to the encoder as each lands; capture never waits on it.
+ * On failure `finish` re-runs `runEncodeStage` on the same frames.
+ */
+export function encodeWhileCapturing(
+ input: EncodeStageInput,
+ totalFrames: number,
+): EncodeWhileCapturing {
+ const engineCfg = resolveEngineConfig(input);
+ const stop = new AbortController();
+ const signal = input.abortSignal
+ ? AbortSignal.any([input.abortSignal, stop.signal])
+ : stop.signal;
+ const landed = new Map<number, string>();
+ let captureDone = false;
+ let framesFed = 0;
+ let wake: (() => void) | null = null;
+ const nudge = () => {
+ wake?.();
+ wake = null;
+ };
+ signal.addEventListener("abort", nudge, { once: true });
+ let reportFed = null as ((frames?: number) => void) | null;
+
+ const encoder = spawnStreamingEncoder(
+ input.videoOnlyPath,
+ { ...videoEncoderOptions(input, engineCfg), imageFormat: "jpeg" },
+ signal,
+ engineCfg,
+ );
+ const fed: Promise<unknown> = (async () => {
+ const stream = await encoder;
+ for (let next = 0; next < totalFrames; next++) {
+ while (!landed.has(next) && !captureDone && !signal.aborted) {
+ await new Promise<void>((resolve) => (wake = resolve));
+ }
+ if (signal.aborted) return;
+ const mergedPath = join(input.framesDir, formatCaptureFrameName(next, "jpg"));
+ const frame = await readLandedFrame(landed.get(next), mergedPath);
+ landed.delete(next);
+ if (!(await stream.writeFrame(frame))) {
+ throw new Error(stream.getExitError() ?? "encoder exited before the last frame");
+ }
+ framesFed++;
+ reportFed?.(framesFed);
+ }
+ })().then(
+ () => undefined,
+ (error: unknown) => error ?? new Error("encode failed"),
+ );
+ const closeEncoder = async () => (await encoder.catch(() => null))?.close();
+
+ return {
+ onFrameLanded: (frame) => {
+ landed.set(frame.index, frame.path);
+ nudge();
+ },
+ finish: async () => {
+ const start = Date.now();
+ captureDone = true;
+ input.log.info("[Render] Encoded frames while capturing", {
+ framesFed,
+ totalFrames,
+ });
+ const encoded = startEncodeProgress(input.job, "Encoding video", input.onProgress);
+ reportFed = encoded;
+ nudge();
+ const failure = await fed;
+ const result = await closeEncoder();
+ input.assertNotAborted();
+ if (failure === undefined && result?.success) {
+ encoded();
+ return { encodeMs: Date.now() - start };
+ }
+ input.log.warn(
+ "[Render] Encoding while capturing failed; encoding the frames after capture",
+ {
+ error: String(failure ?? result?.error),
+ },
+ );
+ return runEncodeStage(input);
+ },
+ abort: async () => {
+ stop.abort();
+ await fed;
+ await closeEncoder();
+ },
+ get framesFed() {
+ return framesFed;
+ },
+ };
+}
+
export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeStageResult> {
const {
job,
@@ -261,16 +434,11 @@ export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeSta
outputPath,
framesDir,
videoOnlyPath,
- width,
- height,
needsAlpha,
hasAudio,
audioOutputPath,
isPngSequence,
isGif,
- preset,
- effectiveQuality,
- effectiveBitrate,
enableChunkedEncode,
chunkedEncodeSize,
abortSignal,
@@ -313,7 +481,7 @@ export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeSta
return { encodeMs: Date.now() - stage5Start };
}
- const engineCfg = input.engineConfig ?? job.config.producerConfig ?? resolveConfig();
+ const engineCfg = resolveEngineConfig(input);
if (isGif) {
// ── Stage 5 (gif): two-pass palette encode ───────────────────────
@@ -357,24 +525,7 @@ export async function runEncodeStage(input: EncodeStageInput): Promise<EncodeSta
const frameExt = frameFileExtension(input.captureImageFormat);
const framePattern = `frame_%06d.${frameExt}`;
- const encoderOpts = {
- fps: job.config.fps,
- width,
- height,
- codec: preset.codec,
- preset: preset.preset,
- quality: effectiveQuality,
- bitrate: effectiveBitrate,
- pixelFormat: preset.pixelFormat,
- vp9CpuUsed: engineCfg.vp9CpuUsed,
- useGpu: job.config.useGpu,
- hdr: preset.hdr,
- // Distributed chunk renders pass these so the encoder writes closed-GOP
- // keyframes that survive `-f concat -c copy` at assemble time. In-process
- // renders leave both undefined → preserves the existing open-GOP output.
- lockGopForChunkConcat: input.lockGopForChunkConcat === true,
- gopSize: input.gopSize,
- };
+ const encoderOpts = videoEncoderOptions(input, engineCfg);
const encodeResult = enableChunkedEncode
? await encodeFramesChunkedConcat(
framesDir,
diff --git a/packages/producer/src/services/render/stages/encodeWhileCapturing.test.ts b/packages/producer/src/services/render/stages/encodeWhileCapturing.test.ts
new file mode 100644
index 0000000000..8c15677778
--- /dev/null
+++ b/packages/producer/src/services/render/stages/encodeWhileCapturing.test.ts
@@ -0,0 +1,136 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { getFfmpegBinary } from "@hyperframes/engine";
+import {
+ canEncodeWhileCapturing,
+ encodeWhileCapturing,
+ runEncodeStage,
+ type EncodeStageInput,
+} from "./encodeStage.js";
+
+const FRAMES = 12;
+const tempDirs: string[] = [];
+
+afterEach(() => {
+ for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+const sha = (path: string) => createHash("sha256").update(readFileSync(path)).digest("hex");
+const frameName = (i: number) => `frame_${String(i).padStart(6, "0")}.jpg`;
+
+/** Two workers' contiguous ranges on disk, as the parallel capture leaves them before the merge. */
+function captureToWorkerDirs() {
+ const root = mkdtempSync(join(tmpdir(), "hf-encode-overlap-"));
+ tempDirs.push(root);
+ const framesDir = join(root, "frames");
+ mkdirSync(framesDir);
+ execFileSync(getFfmpegBinary(), [
+ "-v",
+ "error",
+ "-f",
+ "lavfi",
+ "-i",
+ `testsrc2=s=64x64:r=30:d=${FRAMES / 30}`,
+ "-start_number",
+ "0",
+ join(framesDir, "frame_%06d.jpg"),
+ ]);
+ const landed = [];
+ for (let i = 0; i < FRAMES; i++) {
+ const workerDir = join(root, `worker-${i < FRAMES / 2 ? 0 : 1}`);
+ mkdirSync(workerDir, { recursive: true });
+ renameSync(join(framesDir, frameName(i)), join(workerDir, frameName(i)));
+ landed.push({ index: i, path: join(workerDir, frameName(i)) });
+ }
+ const merge = () =>
+ landed.forEach((f) => renameSync(f.path, join(framesDir, frameName(f.index))));
+ return { root, framesDir, landed, merge };
+}
+
+function makeInput(root: string, framesDir: string, videoOnlyName: string): EncodeStageInput {
+ return {
+ job: {
+ id: "encode-while-capturing-test",
+ config: { fps: { num: 30, den: 1 }, quality: "standard" },
+ status: "queued",
+ progress: 0,
+ currentStage: "queued",
+ createdAt: new Date(0),
+ duration: FRAMES / 30,
+ },
+ log: { error: () => {}, warn: () => {}, info: () => {}, debug: () => {} },
+ outputPath: join(root, "out.mp4"),
+ framesDir,
+ videoOnlyPath: join(root, videoOnlyName),
+ width: 64,
+ height: 64,
+ needsAlpha: false,
+ captureImageFormat: "jpeg",
+ hasAudio: false,
+ isPngSequence: false,
+ isGif: false,
+ preset: { codec: "h264", preset: "medium", quality: 16, pixelFormat: "yuv420p" },
+ effectiveQuality: 16,
+ effectiveBitrate: undefined,
+ enableChunkedEncode: false,
+ chunkedEncodeSize: 30,
+ abortSignal: undefined,
+ assertNotAborted: () => {},
+ };
+}
+
+async function until(condition: () => boolean) {
+ const deadline = Date.now() + 20_000;
+ while (!condition()) {
+ if (Date.now() > deadline) throw new Error("condition not reached");
+ await new Promise((resolve) => setImmediate(resolve));
+ }
+}
+
+describe("encodeWhileCapturing", () => {
+ it("runs only when the capture workers leave a core free for the encoder", () => {
+ const input = makeInput("/r", "/r/frames", "v.mp4");
+ expect(canEncodeWhileCapturing(input, 4, 8)).toBe(true);
+ expect(canEncodeWhileCapturing(input, 4, 4)).toBe(false);
+ expect(canEncodeWhileCapturing(input, 1, 8)).toBe(false);
+ });
+
+ it("encodes in frame order while frames land out of order, byte-identical to the encode after capture", async () => {
+ const { root, framesDir, landed, merge } = captureToWorkerDirs();
+ const overlap = encodeWhileCapturing(makeInput(root, framesDir, "overlap.mp4"), FRAMES);
+ // Worker 1 finishes its range before worker 0 does.
+ for (const frame of [...landed.slice(FRAMES / 2), ...landed.slice(0, FRAMES / 2)]) {
+ overlap.onFrameLanded(frame);
+ }
+ await until(() => overlap.framesFed === FRAMES);
+ merge();
+ await overlap.finish();
+
+ await runEncodeStage(makeInput(root, framesDir, "after.mp4"));
+ expect(sha(join(root, "overlap.mp4"))).toBe(sha(join(root, "after.mp4")));
+ });
+
+ it("reads frames the merge already moved, and frames that never reported landing", async () => {
+ const { root, framesDir, landed, merge } = captureToWorkerDirs();
+ const overlap = encodeWhileCapturing(makeInput(root, framesDir, "overlap.mp4"), FRAMES);
+ landed.slice(0, 3).forEach(overlap.onFrameLanded);
+ merge();
+ await overlap.finish();
+
+ await runEncodeStage(makeInput(root, framesDir, "after.mp4"));
+ expect(sha(join(root, "overlap.mp4"))).toBe(sha(join(root, "after.mp4")));
+ });
+
+ it("abort stops an encoder still waiting on frames", async () => {
+ const { root, framesDir, landed } = captureToWorkerDirs();
+ const overlap = encodeWhileCapturing(makeInput(root, framesDir, "overlap.mp4"), FRAMES);
+ overlap.onFrameLanded(landed[0]!);
+ await until(() => overlap.framesFed === 1);
+ await overlap.abort();
+ expect(overlap.framesFed).toBe(1);
+ });
+});
diff --git a/packages/producer/src/services/renderCommitCancellation.test.ts b/packages/producer/src/services/renderCommitCancellation.test.ts
index 9ae0f47e11..682a7587cb 100644
--- a/packages/producer/src/services/renderCommitCancellation.test.ts
+++ b/packages/producer/src/services/renderCommitCancellation.test.ts
@@ -84,6 +84,7 @@ vi.mock("./render/stages/captureStage.js", async (importOriginal) => ({
}));
vi.mock("./render/stages/encodeStage.js", () => ({
+ canEncodeWhileCapturing: () => false,
runEncodeStage: async ({ outputPath }: { outputPath: string }) => {
mkdirSync(outputPath, { recursive: true });
writeFileSync(join(outputPath, "frame_000001.png"), "new-render");
diff --git a/packages/producer/src/services/renderOrchestrator.ts b/packages/producer/src/services/renderOrchestrator.ts
index 3043282743..2faf76cbc1 100644
--- a/packages/producer/src/services/renderOrchestrator.ts
+++ b/packages/producer/src/services/renderOrchestrator.ts
@@ -211,7 +211,12 @@ import {
runCaptureStreamingStage,
} from "./render/stages/captureStreamingStage.js";
import { runCaptureHdrStage } from "./render/stages/captureHdrStage.js";
-import { runEncodeStage } from "./render/stages/encodeStage.js";
+import {
+ canEncodeWhileCapturing,
+ encodeWhileCapturing,
+ runEncodeStage,
+ type EncodeStageInput,
+} from "./render/stages/encodeStage.js";
import { runAssembleStage } from "./render/stages/assembleStage.js";
import { shouldUseLayeredComposite } from "./hdrCompositor.js";
import {
@@ -4868,6 +4873,40 @@ async function executeRenderPipeline(input: {
}
// ── Disk-based capture (original flow) ────────────────────────────
resetCaptureAttemptProgress(job);
+ const encodeInput: EncodeStageInput = {
+ job,
+ log,
+ outputPath: stagedOutputPath,
+ framesDir,
+ videoOnlyPath,
+ width,
+ height,
+ needsAlpha,
+ captureImageFormat: captureOptions.format ?? "jpeg",
+ hasAudio,
+ audioOutputPath,
+ isPngSequence,
+ isGif,
+ preset,
+ effectiveQuality,
+ effectiveBitrate,
+ enableChunkedEncode,
+ chunkedEncodeSize,
+ engineConfig: cfg,
+ // Same value the streaming encoder above spreads — the disk and
+ // chunked-concat encoders need an identical GOP lock for HLS.
+ ...hlsEncoderGopLock,
+ abortSignal: executionSignal,
+ assertNotAborted,
+ onProgress,
+ };
+ // Not under drawElement: its verify failure discards every frame and recaptures.
+ const overlap =
+ !cfg.useDrawElement &&
+ workerSizing !== undefined &&
+ canEncodeWhileCapturing(encodeInput, capturePlan.workerCount, workerSizing.cpuCount)
+ ? encodeWhileCapturing(encodeInput, totalFrames)
+ : null;
const captureFrameStart = Date.now();
const invokeDiskCapture = (diskPlan: SdrDiskCapturePlan) =>
observeRenderStage(
@@ -4892,12 +4931,14 @@ async function executeRenderPipeline(input: {
abortSignal: executionSignal,
assertNotAborted,
onProgress,
+ onFrameLanded: (frame) => overlap?.onFrameLanded(frame),
}),
);
let captureRes;
try {
captureRes = await invokeDiskCapture(capturePlan);
} catch (err) {
+ await overlap?.abort();
// Disk-path drawElement verification or capture failed. A canvas
// or paint-record failure cannot use the injected page as ground truth.
// Same recovery contract as the streaming drain: re-render on the
@@ -4987,34 +5028,7 @@ async function executeRenderPipeline(input: {
isGif,
chunkedEncode: enableChunkedEncode,
}),
- () =>
- runEncodeStage({
- job,
- log,
- outputPath: stagedOutputPath,
- framesDir,
- videoOnlyPath,
- width,
- height,
- needsAlpha,
- captureImageFormat: captureOptions.format ?? "jpeg",
- hasAudio,
- audioOutputPath,
- isPngSequence,
- isGif,
- preset,
- effectiveQuality,
- effectiveBitrate,
- enableChunkedEncode,
- chunkedEncodeSize,
- engineConfig: cfg,
- // Same value the streaming encoder above spreads — the disk and
- // chunked-concat encoders need an identical GOP lock for HLS.
- ...hlsEncoderGopLock,
- abortSignal: executionSignal,
- assertNotAborted,
- onProgress,
- }),
+ () => (overlap ? overlap.finish() : runEncodeStage(encodeInput)),
);
perfStages.encodeMs = encodeRes.encodeMs;
}
diff --git a/scripts/test-reachability.json b/scripts/test-reachability.json
index 46d3918c86..2e48edb8eb 100644
--- a/scripts/test-reachability.json
+++ b/scripts/test-reachability.json
@@ -61,7 +61,7 @@
],
"sources": {
"packages/producer/scripts/run-test-lane.mjs": "638885e14480d03290803389325a655f3749442167d784e07bb3af3404598af7",
- "packages/producer/scripts/test-classification.mjs": "1f3380ad44971fbf728239b89c35a92d25ccf8ee416f1d77458bddfb7f222965",
+ "packages/producer/scripts/test-classification.mjs": "d55e0caf7939aecfd204db01dc78373961c85896bf3dbe0b1f85a9ed67301bdd",
".github/workflows/ci.yml#job#producer-source-tests": "45da72aa6cf08cdfd5bcf5311e89f12af4842f9eebc6735df19da8c02f4d4864",
"packages/producer/package.json#script#test:unit": "ae6beda8319d166774be958ea5593cd27dbf7f6c9bce1d787a3fe28dfc3477b1",
"packages/producer/package.json#script#test:integration": "008589f37d026877595a13501cbb66abd5cbe50e21fdcac6904f45466c3f475d",