mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-18 16:08:56 +00:00
* feat(engine): decouple transparent background from png capture format PNG capture used to imply a cleared page background. A new CaptureOptions.transparentBackground lets lossless opaque PNG capture (4:4:4 MP4 output) keep the page background. Absent, it still follows format === "png", so alpha output and motion blur are unchanged. Opaque PNG skips drawElement, whose verification and worker-encode paths are JPEG-only. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(engine): add 4:4:4 chroma option to getEncoderPreset getEncoderPreset takes an optional chromaSubsampling ("420" by default). "444" returns yuv444p for SDR MP4, so libx264 encodes the High 4:4:4 Predictive profile and odd sizes need no even padding. WebM, MOV and HDR presets ignore it. The ChromaSubsampling type is exported for the producer. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(producer): chromaSubsampling render option with lossless png capture RenderConfig.chromaSubsampling ("420" by default) opts an SDR MP4 render into 4:4:4. "444" encodes libx264 yuv444p and captures every frame as opaque PNG: Chrome's quality-100 JPEG is already 4:2:0 on beginFrame and screenshot capture, and drawElement can fall back to screenshot mid-render, so PNG is the only capture that keeps the colour. drawElement is turned off for these renders. The probe and main capture options share resolveCaptureSurface, so they cannot disagree on format, quality or background. Formats other than mp4, GPU encoding and HDR output are rejected before any work starts, auto-detected HDR sources fail before capture, and distributed requests refuse 444. The default render is unchanged. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(producer,studio-server): accept chromaSubsampling on render routes The shared parseEncoderOptions validates chromaSubsampling and answers 400 for "444" with a non-mp4 format, gpu, or force-hdr, so a request that would come back 4:2:0 never starts a render. The Studio render route, both Studio adapters and the producer HTTP server forward it. The producer server also refuses "444" with outputDynamicRange "hdr", which parseEncoderOptions cannot see. No Studio UI control; the option is route-level like crf and hdrMode. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * feat(cli): add --chroma-subsampling flag `hyperframes render --chroma-subsampling 444` opts an SDR MP4 render into full-resolution chroma (yuv444p with lossless PNG capture). The default stays 420. The plan rejects 444 with a non-mp4 format, --gpu or --hdr before anything renders, with a usage error that names the conflicting flag. The value reaches the local render request and, only when it is 444, the Docker argv, so default Docker invocations are unchanged. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: document 4:4:4 chroma subsampling Add a "4:4:4 masters" section to the rendering guide: when to use --chroma-subsampling 444, why it captures PNG, the measured chroma gain (large for text and UI, none for footage and gradients), its limits, and a player compatibility table to be filled in from testing. Document the flag in the CLI reference, the built-in rendering docs and the hyperframes-cli skill reference (with the regenerated skills manifest), and the chromaSubsampling option in the producer docs. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: add 4:4:4 player compatibility results Fill the 4:4:4 compatibility table from testing H.264 High 4:4:4 Predictive output. Chrome 155, Edge 155, VLC 3.0, Safari on iOS 26.6 and Safari 26.6 on macOS play it, and so does AVFoundation on macOS 26.6, the framework QuickTime Player plays through. Firefox 157 on Windows and both Windows media players do not. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: note the measured render cost of 4:4:4 output Replace the vague "slower capture" note with measured numbers: a text and UI composition rendered in about twice the default time, full-frame footage in about three and a half times, because PNG encoding cost grows with image detail. Refs #5555 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(producer): reject chromaSubsampling 444 in distributed render config Distributed configs have no chroma field and validateDistributedRenderConfig ignored unknown keys, so a JS caller passing chromaSubsampling: "444" to the Lambda or Cloud Run SDK got a 4:2:0 file with no error. Reject it, and make the rendering guide say so precisely. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(producer): check a 444 render reaches the encoder as yuv444p Every helper had tests, but nothing checked the orchestrator passes chromaSubsampling through, so dropping it from the encoder preset or capture surface would turn 444 renders back into 4:2:0 with all tests green. Render a small fixture with "444" and with the default and check pix_fmt with ffprobe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(producer): move the 444 drawElement gate into a helper Keeps runCompileStage under the fallow complexity threshold. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore: keep comment share at or below the merge-base comment-ratchet failed on 11 files this PR touched. Keep the 4:4:4 rationale once in chromaSubsampling.ts, move the distributed-render reason into its error message, and cut the rest. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(producer): check a 444 render captures full-resolution chroma The encoder check alone passes when chromaSubsampling is dropped from the capture surface: frames are captured as JPEG and encoded yuv444p with 4:2:0 colour. Put a red/blue edge at an odd x, inside a 4:2:0 chroma pair, and require the two pixels to differ in Cb. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(producer): trim the chromaSubsampling.ts header to the package comment share Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix: finish switching to capturesAlpha from #6262 The merge that adopted main's transparent / capturesAlpha left these files uncommitted, so resolveCaptureSurface still returned transparentBackground. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor(engine): use transparent / capturesAlpha from #6262 main added CaptureOptions.transparent and capturesAlpha (#6262), which do what this PR's transparentBackground did. Use them, keep the PNG check in drawElementWorkerEncodeEligible, and re-pin test-classification.mjs and the skills manifest against current main. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore(producer): cut the 4:4:4 comment blocks to one to three lines The reasoning lives in the PR description with the measurements. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * refactor: reconcile 4:4:4 chroma with latest main Keep main's video-layer capture overrides, template entry resolution, ProRes profile parsing and blur-differential tests alongside the chroma option, and fold the encoder sub-parsers into one loop. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * chore: keep main's compile-stage tests and regenerate the skills manifest Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2173 lines
74 KiB
TypeScript
2173 lines
74 KiB
TypeScript
import { spawnSync } from "node:child_process";
|
|
import { EventEmitter } from "node:events";
|
|
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { dirname, join } from "node:path";
|
|
import { afterEach, describe, it, expect, vi } from "vitest";
|
|
import {
|
|
ENCODER_PRESETS,
|
|
appendLockedGopArgs,
|
|
buildConcatArgs,
|
|
buildEncoderArgs,
|
|
getEncoderPreset,
|
|
lockedGopCodecParams,
|
|
resolveLockedGopSize,
|
|
} from "./chunkEncoder.js";
|
|
import { renderProvenanceArgs } from "../utils/renderProvenance.js";
|
|
import {
|
|
SDR_CAPTURE_TO_BT709_FILTER,
|
|
SDR_RGB_TO_TAGGED_BT709_FILTER,
|
|
} from "../utils/sdrCaptureColor.js";
|
|
import { getFfmpegBinary, getFfprobeBinary } from "../utils/ffmpegBinaries.js";
|
|
|
|
const HAS_FFMPEG = spawnSync(getFfmpegBinary(), ["-version"]).status === 0;
|
|
|
|
const TINY_PNG = Buffer.from(
|
|
"iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAACXBIWXMAAAABAAAAAQBPJcTWAAAAEElEQVR4nGP8wwACLGCSAQANBAECv1AVswAAAABJRU5ErkJggg==",
|
|
"base64",
|
|
);
|
|
|
|
const tempDirs: string[] = [];
|
|
|
|
afterEach(() => {
|
|
for (const dir of tempDirs.splice(0)) {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
vi.resetModules();
|
|
vi.doUnmock("child_process");
|
|
vi.doUnmock("../utils/ffprobe.js");
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
function createFrameFixture(): { root: string; framesDir: string } {
|
|
const root = mkdtempSync(join(tmpdir(), "hf-chunk-encoder-"));
|
|
tempDirs.push(root);
|
|
const framesDir = join(root, "frames");
|
|
mkdirSync(framesDir);
|
|
for (let i = 1; i <= 2; i++) {
|
|
writeFileSync(join(framesDir, `frame_${String(i).padStart(6, "0")}.png`), TINY_PNG);
|
|
}
|
|
return { root, framesDir };
|
|
}
|
|
|
|
const tinyEncodeOptions = {
|
|
fps: { num: 30, den: 1 },
|
|
width: 2,
|
|
height: 2,
|
|
codec: "h264" as const,
|
|
preset: "ultrafast",
|
|
quality: 28,
|
|
pixelFormat: "yuv420p",
|
|
useGpu: false,
|
|
};
|
|
|
|
function encodeTimeoutMessage(timeoutMs: number): string {
|
|
return `FFmpeg killed after writing no new frame for ffmpegEncodeTimeout (${timeoutMs} ms)`;
|
|
}
|
|
|
|
type FakeProc = EventEmitter & {
|
|
stderr: EventEmitter;
|
|
kill: ReturnType<typeof vi.fn>;
|
|
killed: boolean;
|
|
};
|
|
|
|
type SpawnCall = {
|
|
command: string;
|
|
args: readonly string[];
|
|
proc: FakeProc;
|
|
};
|
|
|
|
function createFakeProc(): FakeProc {
|
|
const proc = new EventEmitter() as FakeProc;
|
|
proc.stderr = new EventEmitter();
|
|
proc.kill = vi.fn(() => {
|
|
proc.killed = true;
|
|
return true;
|
|
});
|
|
proc.killed = false;
|
|
return proc;
|
|
}
|
|
|
|
function createSpawnSpy(): {
|
|
spawn: (command: string, args: readonly string[]) => FakeProc;
|
|
calls: SpawnCall[];
|
|
} {
|
|
const calls: SpawnCall[] = [];
|
|
const spawn = (command: string, args: readonly string[]): FakeProc => {
|
|
const proc = createFakeProc();
|
|
calls.push({ command, args, proc });
|
|
return proc;
|
|
};
|
|
return { spawn, calls };
|
|
}
|
|
|
|
function emitClose(proc: FakeProc, code: number): void {
|
|
proc.emit("exit", code);
|
|
proc.emit("close", code);
|
|
}
|
|
|
|
async function flushMuxCodecResolution(): Promise<void> {
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
}
|
|
|
|
async function flushManagedProcessResolution(): Promise<void> {
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
}
|
|
|
|
describe("ENCODER_PRESETS", () => {
|
|
it("has draft, standard, and high presets", () => {
|
|
expect(ENCODER_PRESETS).toHaveProperty("draft");
|
|
expect(ENCODER_PRESETS).toHaveProperty("standard");
|
|
expect(ENCODER_PRESETS).toHaveProperty("high");
|
|
});
|
|
|
|
it("draft uses ultrafast preset with high CRF", () => {
|
|
expect(ENCODER_PRESETS.draft.preset).toBe("ultrafast");
|
|
expect(ENCODER_PRESETS.draft.quality).toBeGreaterThan(ENCODER_PRESETS.standard.quality);
|
|
expect(ENCODER_PRESETS.draft.codec).toBe("h264");
|
|
});
|
|
|
|
it("high uses the fast preset with low CRF for better quality", () => {
|
|
expect(ENCODER_PRESETS.high.preset).toBe("fast");
|
|
expect(ENCODER_PRESETS.high.quality).toBeLessThan(ENCODER_PRESETS.standard.quality);
|
|
expect(ENCODER_PRESETS.high.codec).toBe("h264");
|
|
});
|
|
|
|
it("standard sits between draft and high in quality", () => {
|
|
expect(ENCODER_PRESETS.standard.quality).toBeGreaterThan(ENCODER_PRESETS.high.quality);
|
|
expect(ENCODER_PRESETS.standard.quality).toBeLessThan(ENCODER_PRESETS.draft.quality);
|
|
});
|
|
});
|
|
|
|
describe("encodeFramesFromDir ffmpegEncodeTimeout", () => {
|
|
it("kills ffmpeg when config timeout elapses", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesFromDir } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesFromDir(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "timeout.mp4"),
|
|
tinyEncodeOptions,
|
|
undefined,
|
|
{ ffmpegEncodeTimeout: 1000 },
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const proc = calls[0]!.proc;
|
|
vi.advanceTimersByTime(999);
|
|
expect(proc.kill).not.toHaveBeenCalled();
|
|
|
|
vi.advanceTimersByTime(1);
|
|
expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
|
|
|
|
proc.stderr.emit("data", Buffer.from("terminated by timeout\n"));
|
|
emitClose(proc, 143);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("FFmpeg exited with code 143");
|
|
expect(result.error).toContain("terminated by timeout");
|
|
expect(result.error).toContain(encodeTimeoutMessage(1000));
|
|
expect(result.error).toContain("FFMPEG_ENCODE_TIMEOUT_MS");
|
|
// Chunking does not help an encode that writes no frames, so it is no longer suggested.
|
|
expect(result.error).not.toContain("PRODUCER_ENABLE_CHUNKED_ENCODE");
|
|
});
|
|
|
|
it("keeps an encode going past the timeout while its frame count advances", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesFromDir } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesFromDir(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "slow.mp4"),
|
|
tinyEncodeOptions,
|
|
undefined,
|
|
{ ffmpegEncodeTimeout: 1000 },
|
|
);
|
|
|
|
const proc = calls[0]!.proc;
|
|
for (let frame = 1; frame <= 4; frame += 1) {
|
|
vi.advanceTimersByTime(900);
|
|
proc.stderr.emit(
|
|
"data",
|
|
Buffer.from(`frame=${frame} fps=1 q=28.0 time=00:00:0${frame}.00\r`),
|
|
);
|
|
}
|
|
expect(proc.kill).not.toHaveBeenCalled();
|
|
emitClose(proc, 0);
|
|
|
|
await expect(encodePromise).resolves.toMatchObject({ success: true, framesEncoded: 2 });
|
|
});
|
|
|
|
it("keeps non-timeout ffmpeg failures unchanged", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesFromDir } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesFromDir(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "failure.mp4"),
|
|
tinyEncodeOptions,
|
|
undefined,
|
|
{ ffmpegEncodeTimeout: 1000 },
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const proc = calls[0]!.proc;
|
|
proc.stderr.emit("data", Buffer.from("encoder failed\n"));
|
|
emitClose(proc, 1);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("FFmpeg exited with code 1");
|
|
expect(result.error).toContain("encoder failed");
|
|
expect(result.error).not.toContain("ffmpegEncodeTimeout");
|
|
});
|
|
|
|
it("uses the default timeout when config is omitted", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesFromDir } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesFromDir(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "default.mp4"),
|
|
tinyEncodeOptions,
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const proc = calls[0]!.proc;
|
|
vi.advanceTimersByTime(599_999);
|
|
expect(proc.kill).not.toHaveBeenCalled();
|
|
|
|
emitClose(proc, 0);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(true);
|
|
expect(result.framesEncoded).toBe(2);
|
|
expect(result.fileSize).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe("encodeFramesChunkedConcat ffmpegEncodeTimeout", () => {
|
|
it("isolates concurrent encodes and preserves pre-existing chunk files", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
const { encodeFramesChunkedConcat } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
const legacyDir = join(root, "chunk-encode");
|
|
mkdirSync(legacyDir);
|
|
const legacyList = join(legacyDir, "concat-list.txt");
|
|
writeFileSync(legacyList, "another render's concat list");
|
|
|
|
const results = ["first.mp4", "second.mp4"].map((name) =>
|
|
encodeFramesChunkedConcat(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, name),
|
|
tinyEncodeOptions,
|
|
30,
|
|
),
|
|
);
|
|
expect(calls).toHaveLength(2);
|
|
const chunkPaths = calls.map((call) => call.args.at(-1));
|
|
for (const call of [...calls]) emitClose(call.proc, 0);
|
|
await flushManagedProcessResolution();
|
|
expect(calls).toHaveLength(4);
|
|
const lists = calls.slice(2).map((call) => call.args[call.args.indexOf("-i") + 1]);
|
|
for (const call of calls.slice(2)) emitClose(call.proc, 0);
|
|
const completed = await Promise.all(results);
|
|
|
|
expect(completed.every((result) => result.success && result.framesEncoded === 2)).toBe(true);
|
|
expect(new Set(chunkPaths).size).toBe(2);
|
|
expect(new Set(lists).size).toBe(2);
|
|
for (let index = 0; index < 2; index++) {
|
|
const chunkPath = chunkPaths[index];
|
|
const list = lists[index];
|
|
if (!chunkPath || !list) throw new Error("Expected chunk and concat paths");
|
|
expect(dirname(chunkPath)).not.toBe(legacyDir);
|
|
expect(dirname(list)).toBe(dirname(chunkPath));
|
|
expect(dirname(dirname(list))).toBe(root);
|
|
expect(readFileSync(list, "utf8")).toBe(`file '${chunkPath.replace(/'/g, "'\\''")}'`);
|
|
}
|
|
expect(readFileSync(legacyList, "utf8")).toBe("another render's concat list");
|
|
});
|
|
|
|
it("passes config timeout to per-chunk encodes", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesChunkedConcat } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesChunkedConcat(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "chunked.mp4"),
|
|
tinyEncodeOptions,
|
|
30,
|
|
undefined,
|
|
{ ffmpegEncodeTimeout: 1000 },
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const proc = calls[0]!.proc;
|
|
vi.advanceTimersByTime(999);
|
|
expect(proc.kill).not.toHaveBeenCalled();
|
|
|
|
vi.advanceTimersByTime(1);
|
|
expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
|
|
|
|
proc.stderr.emit("data", Buffer.from("chunk timeout\n"));
|
|
emitClose(proc, 143);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("Chunk 0 encode failed");
|
|
expect(result.error).toContain("chunk timeout");
|
|
expect(result.error).toContain(encodeTimeoutMessage(1000));
|
|
});
|
|
|
|
it("keeps non-timeout chunk failures unchanged", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesChunkedConcat } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesChunkedConcat(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "chunked-failure.mp4"),
|
|
tinyEncodeOptions,
|
|
30,
|
|
undefined,
|
|
{ ffmpegEncodeTimeout: 1000 },
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const proc = calls[0]!.proc;
|
|
proc.stderr.emit("data", Buffer.from("chunk failed\n"));
|
|
emitClose(proc, 1);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toBe("Chunk 0 encode failed: chunk failed\n");
|
|
expect(result.error).not.toContain("ffmpegEncodeTimeout");
|
|
});
|
|
|
|
it("kills concat ffmpeg when config timeout elapses", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesChunkedConcat } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesChunkedConcat(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "concat-timeout.mp4"),
|
|
tinyEncodeOptions,
|
|
30,
|
|
undefined,
|
|
{ ffmpegEncodeTimeout: 1000 },
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
emitClose(calls[0]!.proc, 0);
|
|
await flushManagedProcessResolution();
|
|
|
|
expect(calls).toHaveLength(2);
|
|
const concatProc = calls[1]!.proc;
|
|
vi.advanceTimersByTime(999);
|
|
expect(concatProc.kill).not.toHaveBeenCalled();
|
|
|
|
vi.advanceTimersByTime(1);
|
|
expect(concatProc.kill).toHaveBeenCalledWith("SIGTERM");
|
|
|
|
concatProc.stderr.emit("data", Buffer.from("concat timeout\n"));
|
|
emitClose(concatProc, 143);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain("Chunk concat failed");
|
|
expect(result.error).toContain("concat timeout");
|
|
expect(result.error).toContain(encodeTimeoutMessage(1000));
|
|
});
|
|
|
|
it("uses the default timeout for per-chunk encodes when config is omitted", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { encodeFramesChunkedConcat } = await import("./chunkEncoder.js");
|
|
const { root, framesDir } = createFrameFixture();
|
|
|
|
const encodePromise = encodeFramesChunkedConcat(
|
|
framesDir,
|
|
"frame_%06d.png",
|
|
join(root, "chunked-default.mp4"),
|
|
tinyEncodeOptions,
|
|
30,
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const chunkProc = calls[0]!.proc;
|
|
vi.advanceTimersByTime(599_999);
|
|
expect(chunkProc.kill).not.toHaveBeenCalled();
|
|
|
|
emitClose(chunkProc, 0);
|
|
await flushManagedProcessResolution();
|
|
|
|
expect(calls).toHaveLength(2);
|
|
const concatProc = calls[1]!.proc;
|
|
emitClose(concatProc, 0);
|
|
|
|
const result = await encodePromise;
|
|
expect(result.success).toBe(true);
|
|
expect(result.framesEncoded).toBe(2);
|
|
expect(result.fileSize).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe("final mux and faststart ffmpegProcessTimeout", () => {
|
|
afterEach(() => vi.useRealTimers());
|
|
|
|
it("reports a mux killed at the configured timeout as a timeout", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio.aac",
|
|
"/tmp/output.mp4",
|
|
undefined,
|
|
{ ffmpegProcessTimeout: 1000 },
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
const proc = calls[0]!.proc;
|
|
vi.advanceTimersByTime(999);
|
|
expect(proc.kill).not.toHaveBeenCalled();
|
|
vi.advanceTimersByTime(1);
|
|
expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
|
|
proc.stderr.emit("data", Buffer.from("frame= 9000 time=00:05:00.00\n"));
|
|
emitClose(proc, 255);
|
|
|
|
const result = await muxPromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toMatch(/^FFmpeg timed out after 1000 ms/);
|
|
expect(result.error).toContain("FFMPEG_PROCESS_TIMEOUT_MS");
|
|
expect(result.error).toContain("frame= 9000");
|
|
});
|
|
|
|
it("reports a faststart killed at the configured timeout as a timeout", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { applyFaststart } = await import("./chunkEncoder.js");
|
|
const faststartPromise = applyFaststart("/tmp/video-only.mp4", "/tmp/output.mp4", undefined, {
|
|
ffmpegProcessTimeout: 2000,
|
|
});
|
|
|
|
const proc = calls[0]!.proc;
|
|
vi.advanceTimersByTime(1999);
|
|
expect(proc.kill).not.toHaveBeenCalled();
|
|
vi.advanceTimersByTime(1);
|
|
expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
|
|
emitClose(proc, 255);
|
|
|
|
const result = await faststartPromise;
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toMatch(/^FFmpeg timed out after 2000 ms/);
|
|
});
|
|
|
|
it("leaves an ordinary mux failure's message as it was", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio("/tmp/video-only.mp4", "/tmp/audio.aac", "/tmp/out.mp4");
|
|
await flushMuxCodecResolution();
|
|
calls[0]!.proc.stderr.emit("data", Buffer.from("Invalid data found when processing input\n"));
|
|
emitClose(calls[0]!.proc, 1);
|
|
|
|
const result = await muxPromise;
|
|
expect(result.error).toMatch(/^FFmpeg exited with code 1/);
|
|
expect(result.error).not.toContain("timed out");
|
|
});
|
|
});
|
|
|
|
describe("muxVideoWithAudio audio codec handling", () => {
|
|
it("preserves an external interruption from mux", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio.aac",
|
|
"/tmp/output.mp4",
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
calls[0]!.proc.stderr.emit("data", Buffer.from("Exiting normally, received signal 15.\n"));
|
|
emitClose(calls[0]!.proc, 255);
|
|
|
|
await expect(muxPromise).resolves.toMatchObject({
|
|
success: false,
|
|
failureReason: "external_interruption",
|
|
});
|
|
});
|
|
|
|
it("preserves an external interruption from faststart", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { applyFaststart } = await import("./chunkEncoder.js");
|
|
const faststartPromise = applyFaststart("/tmp/video-only.mp4", "/tmp/output.mp4");
|
|
|
|
calls[0]!.proc.stderr.emit("data", Buffer.from("Exiting normally, received signal 15.\n"));
|
|
emitClose(calls[0]!.proc, 255);
|
|
|
|
await expect(faststartPromise).resolves.toMatchObject({
|
|
success: false,
|
|
failureReason: "external_interruption",
|
|
});
|
|
});
|
|
|
|
it("copies HyperFrames AAC sidecars into MP4 instead of re-encoding", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio.aac",
|
|
"/tmp/output.mp4",
|
|
undefined,
|
|
undefined,
|
|
{ num: 30, den: 1 },
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toEqual([
|
|
"-i",
|
|
"/tmp/video-only.mp4",
|
|
"-i",
|
|
"/tmp/audio.aac",
|
|
"-c:v",
|
|
"copy",
|
|
"-c:a",
|
|
"copy",
|
|
"-movflags",
|
|
"+faststart",
|
|
...renderProvenanceArgs("/tmp/output.mp4"),
|
|
"-r",
|
|
"30",
|
|
"-y",
|
|
"/tmp/output.mp4",
|
|
]);
|
|
expect(calls[0]!.args).not.toContain("-shortest");
|
|
expect(calls[0]!.args).not.toContain("-use_editlist");
|
|
// The faststart flag set above must survive the provenance flag: ffmpeg
|
|
// takes the last -movflags occurrence, and a non-additive one would drop it.
|
|
expect(calls[0]!.args.filter((a) => a === "-movflags")).toHaveLength(2);
|
|
expect(calls[0]!.args).toContain("+faststart");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({
|
|
success: true,
|
|
outputPath: "/tmp/output.mp4",
|
|
});
|
|
});
|
|
|
|
it("never repairs negative timestamps for an M4A sidecar (regression #3487)", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio.duration-normalized.m4a",
|
|
"/tmp/output.mp4",
|
|
undefined,
|
|
{ audioCodec: "aac" },
|
|
{ num: 30, den: 1 },
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("copy");
|
|
// `make_zero` would discard the sidecar's AAC priming edit list, shift
|
|
// the copied video forward ~21ms and leave an empty video edit at t=0.
|
|
expect(calls[0]!.args).not.toContain("-avoid_negative_ts");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({ success: true });
|
|
});
|
|
|
|
it("ignores the deprecated preserveAudioPrimingEditList option", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio.duration-normalized.m4a",
|
|
"/tmp/output.mp4",
|
|
undefined,
|
|
{ audioCodec: "aac", preserveAudioPrimingEditList: false },
|
|
{ num: 30, den: 1 },
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("copy");
|
|
expect(calls[0]!.args).not.toContain("-avoid_negative_ts");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({ success: true });
|
|
});
|
|
|
|
it("uses the caller-provided AAC codec contract instead of the sidecar extension", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio-sidecar",
|
|
"/tmp/output.mp4",
|
|
undefined,
|
|
{ audioCodec: "aac" },
|
|
{ num: 30, den: 1 },
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-c:a");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-c:a") + 1]).toBe("copy");
|
|
expect(calls[0]!.args).not.toContain("-b:a");
|
|
expect(calls[0]!.args).toContain("+faststart");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({
|
|
success: true,
|
|
outputPath: "/tmp/output.mp4",
|
|
});
|
|
});
|
|
|
|
it("probes unknown-extension AAC sidecars before choosing the MP4 copy path", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const extractAudioMetadata = vi.fn(async () => ({
|
|
durationSeconds: 1,
|
|
sampleRate: 48000,
|
|
channels: 2,
|
|
audioCodec: "aac",
|
|
}));
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
vi.doMock("../utils/ffprobe.js", () => ({ extractAudioMetadata }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio-sidecar",
|
|
"/tmp/output.mp4",
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(extractAudioMetadata).toHaveBeenCalledWith("/tmp/audio-sidecar");
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-c:a");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-c:a") + 1]).toBe("copy");
|
|
expect(calls[0]!.args).not.toContain("-b:a");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({
|
|
success: true,
|
|
outputPath: "/tmp/output.mp4",
|
|
});
|
|
});
|
|
|
|
it("keeps probed non-AAC unknown-extension sidecars on the MP4 transcode path", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const extractAudioMetadata = vi.fn(async () => ({
|
|
durationSeconds: 1,
|
|
sampleRate: 48000,
|
|
channels: 2,
|
|
audioCodec: "mp3",
|
|
}));
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
vi.doMock("../utils/ffprobe.js", () => ({ extractAudioMetadata }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio-sidecar",
|
|
"/tmp/output.mp4",
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(extractAudioMetadata).toHaveBeenCalledWith("/tmp/audio-sidecar");
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-c:a");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-c:a") + 1]).toBe("aac");
|
|
expect(calls[0]!.args).toContain("-b:a");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({ success: true });
|
|
});
|
|
|
|
it("still transcodes non-AAC audio when muxing MP4", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mp4",
|
|
"/tmp/audio.wav",
|
|
"/tmp/output.mp4",
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-c:a");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-c:a") + 1]).toBe("aac");
|
|
expect(calls[0]!.args).toContain("-b:a");
|
|
expect(calls[0]!.args).toContain("+faststart");
|
|
expect(calls[0]!.args).not.toContain("-avoid_negative_ts");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({ success: true });
|
|
});
|
|
|
|
it("copies HyperFrames AAC sidecars into MOV containers without MP4 faststart flags", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.mov",
|
|
"/tmp/audio.aac",
|
|
"/tmp/output.mov",
|
|
);
|
|
|
|
await flushMuxCodecResolution();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-c:a");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-c:a") + 1]).toBe("copy");
|
|
expect(calls[0]!.args).not.toContain("-b:a");
|
|
expect(calls[0]!.args).not.toContain("+faststart");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({ success: true });
|
|
});
|
|
|
|
it("does not pass -shortest to ffmpeg (regression #1648)", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
|
|
for (const ext of [".mp4", ".mov", ".webm"] as const) {
|
|
const muxPromise = muxVideoWithAudio(
|
|
`/tmp/video-only${ext}`,
|
|
"/tmp/audio.aac",
|
|
`/tmp/output${ext}`,
|
|
undefined,
|
|
undefined,
|
|
{ num: 30, den: 1 },
|
|
);
|
|
if (ext !== ".webm") await flushMuxCodecResolution();
|
|
const call = calls[calls.length - 1]!;
|
|
expect(call.args).not.toContain("-shortest");
|
|
// Same for every container we mux into: ffmpeg's `auto` default is
|
|
// already `disabled` for mp4/mov, and forcing `make_zero` breaks the
|
|
// AAC priming edit list (#3487).
|
|
expect(call.args).not.toContain("-avoid_negative_ts");
|
|
emitClose(call.proc, 0);
|
|
await muxPromise;
|
|
}
|
|
});
|
|
|
|
it("keeps WebM audio on the Opus transcode path", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("child_process", () => ({ spawn }));
|
|
|
|
const { muxVideoWithAudio } = await import("./chunkEncoder.js");
|
|
const muxPromise = muxVideoWithAudio(
|
|
"/tmp/video-only.webm",
|
|
"/tmp/audio.aac",
|
|
"/tmp/output.webm",
|
|
);
|
|
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-c:a");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-c:a") + 1]).toBe("libopus");
|
|
expect(calls[0]!.args).not.toContain("+faststart");
|
|
|
|
emitClose(calls[0]!.proc, 0);
|
|
await expect(muxPromise).resolves.toMatchObject({ success: true });
|
|
});
|
|
});
|
|
|
|
describe("getEncoderPreset", () => {
|
|
it("returns h264 with yuv420p for mp4 format", () => {
|
|
const preset = getEncoderPreset("standard", "mp4");
|
|
expect(preset.codec).toBe("h264");
|
|
expect(preset.pixelFormat).toBe("yuv420p");
|
|
});
|
|
|
|
it("returns vp9 with yuva420p for webm format", () => {
|
|
const preset = getEncoderPreset("standard", "webm");
|
|
expect(preset.codec).toBe("vp9");
|
|
expect(preset.pixelFormat).toBe("yuva420p");
|
|
});
|
|
|
|
it("maps draft ultrafast to vp9 realtime deadline", () => {
|
|
const preset = getEncoderPreset("draft", "webm");
|
|
expect(preset.preset).toBe("realtime");
|
|
expect(preset.codec).toBe("vp9");
|
|
});
|
|
|
|
it("maps standard/high to vp9 good deadline", () => {
|
|
expect(getEncoderPreset("standard", "webm").preset).toBe("good");
|
|
expect(getEncoderPreset("high", "webm").preset).toBe("good");
|
|
});
|
|
|
|
it("preserves quality values across formats", () => {
|
|
for (const q of ["draft", "standard", "high"] as const) {
|
|
expect(getEncoderPreset(q, "webm").quality).toBe(ENCODER_PRESETS[q].quality);
|
|
}
|
|
});
|
|
|
|
it("returns prores 4444 with yuva444p10le for mov format", () => {
|
|
const preset = getEncoderPreset("standard", "mov");
|
|
expect(preset.codec).toBe("prores");
|
|
expect(preset.preset).toBe("4444");
|
|
expect(preset.pixelFormat).toBe("yuva444p10le");
|
|
});
|
|
|
|
it.each([
|
|
["4444", "4444", "yuva444p10le"],
|
|
["hq", "3", "yuv422p10le"],
|
|
["422", "2", "yuv422p10le"],
|
|
["lt", "1", "yuv422p10le"],
|
|
["proxy", "0", "yuv422p10le"],
|
|
] as const)("maps ProRes profile %s to -profile:v %s and %s", (name, profile, pixelFormat) => {
|
|
const preset = getEncoderPreset("standard", "mov", undefined, name);
|
|
expect(preset).toMatchObject({ codec: "prores", preset: profile, pixelFormat });
|
|
const args = buildEncoderArgs(
|
|
{
|
|
fps: { num: 30, den: 1 },
|
|
width: 1920,
|
|
height: 1080,
|
|
codec: "prores",
|
|
preset: preset.preset,
|
|
quality: 23,
|
|
pixelFormat,
|
|
},
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mov",
|
|
);
|
|
expect(args[args.indexOf("-profile:v") + 1]).toBe(profile);
|
|
expect(args[args.indexOf("-pix_fmt") + 1]).toBe(pixelFormat);
|
|
});
|
|
|
|
it("uses prores 4444 for all mov quality levels", () => {
|
|
for (const q of ["draft", "standard", "high"] as const) {
|
|
const preset = getEncoderPreset(q, "mov");
|
|
expect(preset.codec).toBe("prores");
|
|
expect(preset.preset).toBe("4444");
|
|
}
|
|
});
|
|
|
|
it("defaults to mp4 when format is omitted", () => {
|
|
const preset = getEncoderPreset("standard");
|
|
expect(preset.codec).toBe("h264");
|
|
expect(preset.pixelFormat).toBe("yuv420p");
|
|
});
|
|
|
|
it("returns yuv444p for SDR mp4 when 4:4:4 chroma is requested", () => {
|
|
for (const q of ["draft", "standard", "high"] as const) {
|
|
const preset = getEncoderPreset(q, "mp4", undefined, undefined, "444");
|
|
expect(preset.codec).toBe("h264");
|
|
expect(preset.preset).toBe(ENCODER_PRESETS[q].preset);
|
|
expect(preset.pixelFormat).toBe("yuv444p");
|
|
}
|
|
});
|
|
|
|
it("keeps yuv420p for SDR mp4 when 4:2:0 chroma is requested explicitly", () => {
|
|
expect(getEncoderPreset("standard", "mp4", undefined, "420").pixelFormat).toBe("yuv420p");
|
|
});
|
|
|
|
it("ignores the chroma option for webm, mov and HDR presets", () => {
|
|
expect(getEncoderPreset("standard", "webm", undefined, undefined, "444").pixelFormat).toBe(
|
|
"yuva420p",
|
|
);
|
|
expect(getEncoderPreset("standard", "mov", undefined, undefined, "444").pixelFormat).toBe(
|
|
"yuva444p10le",
|
|
);
|
|
expect(
|
|
getEncoderPreset("standard", "mp4", { transfer: "pq" }, undefined, "444").pixelFormat,
|
|
).toBe("yuv420p10le");
|
|
});
|
|
});
|
|
|
|
describe("buildEncoderArgs anti-banding", () => {
|
|
const baseOptions = { fps: { num: 30, den: 1 }, width: 1920, height: 1080 };
|
|
|
|
it("adds aq-mode=3 x264-params for h264 CPU encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23 },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(paramIdx).toBeGreaterThan(-1);
|
|
expect(args[paramIdx + 1]).toContain("aq-mode=3");
|
|
});
|
|
|
|
it("adds aq-mode=3 x265-params for h265 CPU encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23 },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(paramIdx).toBeGreaterThan(-1);
|
|
expect(args[paramIdx + 1]).toContain("aq-mode=3");
|
|
});
|
|
|
|
it("includes deblock for non-ultrafast presets", () => {
|
|
for (const preset of ["medium", "slow"]) {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset, quality: 23 },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).toContain("deblock=1,1");
|
|
}
|
|
});
|
|
|
|
it("omits deblock for ultrafast (draft) preset", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "ultrafast", quality: 28 },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(paramIdx).toBeGreaterThan(-1);
|
|
expect(args[paramIdx + 1]).toContain("aq-mode=3");
|
|
expect(args[paramIdx + 1]).not.toContain("deblock");
|
|
});
|
|
|
|
it("does not add x264-params for GPU encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23, useGpu: true },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(args.indexOf("-x264-params")).toBe(-1);
|
|
});
|
|
|
|
it("does not add x264-params for VP9 encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "vp9", preset: "good", quality: 23 },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.webm",
|
|
);
|
|
expect(args.indexOf("-x264-params")).toBe(-1);
|
|
expect(args.indexOf("-x265-params")).toBe(-1);
|
|
});
|
|
});
|
|
|
|
describe("buildEncoderArgs fps rational forwarding", () => {
|
|
// Regression for the fps fraction-syntax feature: rational fps must reach
|
|
// ffmpeg's `-r` flag verbatim (e.g. "30000/1001") so NTSC stays exact end-
|
|
// to-end rather than being rounded to 29.97 decimal at the encoder boundary.
|
|
it("emits integer -r for { num: 30, den: 1 }", () => {
|
|
const args = buildEncoderArgs(
|
|
{ fps: { num: 30, den: 1 }, width: 1920, height: 1080, codec: "h264" },
|
|
["-framerate", "30", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
);
|
|
const rIdx = args.indexOf("-r");
|
|
expect(rIdx).toBeGreaterThan(-1);
|
|
expect(args[rIdx + 1]).toBe("30");
|
|
});
|
|
|
|
it("emits rational -r for NTSC { num: 30000, den: 1001 }", () => {
|
|
const args = buildEncoderArgs(
|
|
{ fps: { num: 30000, den: 1001 }, width: 1920, height: 1080, codec: "h264" },
|
|
["-framerate", "30000/1001", "-i", "frames/%04d.png"],
|
|
"out.mp4",
|
|
);
|
|
const rIdx = args.indexOf("-r");
|
|
expect(rIdx).toBeGreaterThan(-1);
|
|
expect(args[rIdx + 1]).toBe("30000/1001");
|
|
});
|
|
});
|
|
|
|
describe("buildEncoderArgs GPU preset mapping", () => {
|
|
const baseOptions = { fps: { num: 30, den: 1 }, width: 1920, height: 1080 };
|
|
const inputArgs = ["-framerate", "30", "-i", "frames/%04d.png"];
|
|
|
|
function presetArg(args: string[]): string | undefined {
|
|
const idx = args.indexOf("-preset");
|
|
return idx === -1 ? undefined : args[idx + 1];
|
|
}
|
|
|
|
// Regression for the "draft quality + --gpu fails with code -22" bug:
|
|
// NVENC rejects the libx264 preset name `ultrafast` with AVERROR(EINVAL),
|
|
// so the `draft` quality tier must not forward that value to h264_nvenc.
|
|
it("translates the draft ultrafast preset to NVENC p1", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "ultrafast", quality: 28, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(presetArg(args)).toBe("p1");
|
|
});
|
|
|
|
it("gives an NVENC build that lists only legacy presets a legacy preset, not p4", () => {
|
|
const legacy = new Set(["default", "slow", "medium", "fast", "hp", "hq"]);
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 18, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
legacy,
|
|
);
|
|
expect(presetArg(args)).toBe("medium");
|
|
});
|
|
|
|
it("translates the standard medium preset to NVENC p4", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 18, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(presetArg(args)).toBe("p4");
|
|
});
|
|
|
|
it("translates the slow preset to NVENC p5", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "slow", quality: 15, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(presetArg(args)).toBe("p5");
|
|
});
|
|
|
|
it("uses a supported derived bitrate for high-quality VideoToolbox", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
fps: { num: 24, den: 1 },
|
|
width: 1920,
|
|
height: 1080,
|
|
codec: "h264",
|
|
preset: "slow",
|
|
quality: 15,
|
|
useGpu: true,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
"videotoolbox",
|
|
);
|
|
|
|
expect(args).not.toContain("-q:v");
|
|
expect(args[args.indexOf("-b:v") + 1]).toBe("12M");
|
|
expect(args[args.indexOf("-allow_sw") + 1]).toBe("1");
|
|
});
|
|
|
|
// hevc_nvenc uses the same p1..p7 preset vocabulary as h264_nvenc, so the
|
|
// mapping must apply to both codecs. Locks in "H.264 and H.265 NVENC share
|
|
// the preset mapping" against a future refactor that might split the path.
|
|
it("translates libx264 preset names to NVENC p1..p7 for h265 as well", () => {
|
|
for (const [libx264, nvencPreset] of [
|
|
["ultrafast", "p1"],
|
|
["medium", "p4"],
|
|
["veryslow", "p7"],
|
|
] as const) {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: libx264, quality: 23, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(args[args.indexOf("-c:v") + 1]).toBe("hevc_nvenc");
|
|
expect(presetArg(args)).toBe(nvencPreset);
|
|
}
|
|
});
|
|
|
|
it("rewrites QSV's unsupported ultrafast preset to veryfast", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "ultrafast", quality: 28, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"qsv",
|
|
);
|
|
expect(presetArg(args)).toBe("veryfast");
|
|
});
|
|
|
|
it("passes QSV-supported preset names through unchanged", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"qsv",
|
|
);
|
|
expect(presetArg(args)).toBe("medium");
|
|
});
|
|
|
|
it("uses AMD AMF encoder names and quality flags when selected", () => {
|
|
const h264Args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"amf",
|
|
);
|
|
expect(h264Args[h264Args.indexOf("-c:v") + 1]).toBe("h264_amf");
|
|
expect(h264Args[h264Args.indexOf("-qp_i") + 1]).toBe("23");
|
|
expect(h264Args).toContain("-bf");
|
|
expect(h264Args[h264Args.indexOf("-bf") + 1]).toBe("0");
|
|
|
|
const h265Args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"amf",
|
|
);
|
|
expect(h265Args[h265Args.indexOf("-c:v") + 1]).toBe("hevc_amf");
|
|
expect(h265Args[h265Args.indexOf("-qp_i") + 1]).toBe("23");
|
|
});
|
|
});
|
|
|
|
describe("buildEncoderArgs color space", () => {
|
|
const baseOptions = { fps: { num: 30, den: 1 }, width: 1920, height: 1080 };
|
|
const inputArgs = ["-framerate", "30", "-i", "frames/%04d.png"];
|
|
|
|
it("adds bt709 color space metadata for h264 CPU encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
// FFmpeg-level metadata tags
|
|
expect(args).toContain("-colorspace:v");
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_primaries:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_trc:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_range") + 1]).toBe("tv");
|
|
// x264-params VUI embedding
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt709");
|
|
expect(args[paramIdx + 1]).toContain("transfer=bt709");
|
|
expect(args[paramIdx + 1]).toContain("colormatrix=bt709");
|
|
});
|
|
|
|
it("adds bt709 color space metadata for h265 CPU encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args).toContain("-colorspace:v");
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt709");
|
|
// x265-params VUI embedding
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt709");
|
|
});
|
|
|
|
it("adds range conversion filter for CPU h264 encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const vfIdx = args.indexOf("-vf");
|
|
expect(vfIdx).toBeGreaterThan(-1);
|
|
expect(args[vfIdx + 1]).toBe(SDR_CAPTURE_TO_BT709_FILTER);
|
|
});
|
|
|
|
it("adds the pad after range conversion for odd CPU output dimensions", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, height: 1081, codec: "h264", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const vfIdx = args.indexOf("-vf");
|
|
expect(args[vfIdx + 1]).toBe(`${SDR_CAPTURE_TO_BT709_FILTER},pad=ceil(iw/2)*2:ceil(ih/2)*2`);
|
|
});
|
|
|
|
it("encodes 4:4:4 at odd dimensions without padding, keeping BT.709 tags", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
width: 1081,
|
|
height: 721,
|
|
codec: "h264",
|
|
preset: "medium",
|
|
quality: 18,
|
|
pixelFormat: "yuv444p",
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-c:v") + 1]).toBe("libx264");
|
|
expect(args[args.indexOf("-pix_fmt") + 1]).toBe("yuv444p");
|
|
expect(args[args.indexOf("-vf") + 1]).toBe(SDR_CAPTURE_TO_BT709_FILTER);
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_range") + 1]).toBe("tv");
|
|
});
|
|
|
|
it("prepends range conversion to VAAPI filter chain", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"vaapi",
|
|
);
|
|
const vfIdx = args.indexOf("-vf");
|
|
expect(vfIdx).toBeGreaterThan(-1);
|
|
expect(args[vfIdx + 1]).toBe(`${SDR_CAPTURE_TO_BT709_FILTER},format=nv12,hwupload`);
|
|
});
|
|
|
|
it("converts to BT.709 and pads odd dimensions for non-VAAPI GPU encoding", () => {
|
|
for (const gpu of ["nvenc", "videotoolbox", "qsv", "amf"] as const) {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
height: 1081,
|
|
codec: "h264",
|
|
preset: "medium",
|
|
quality: 23,
|
|
useGpu: true,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
gpu,
|
|
);
|
|
const vfIdx = args.indexOf("-vf");
|
|
expect(args[vfIdx + 1]).toBe(`${SDR_CAPTURE_TO_BT709_FILTER},pad=ceil(iw/2)*2:ceil(ih/2)*2`);
|
|
// but still has color metadata
|
|
expect(args).toContain("-colorspace:v");
|
|
}
|
|
});
|
|
|
|
it("does not require the pad filter for even GPU output dimensions", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23, useGpu: true },
|
|
inputArgs,
|
|
"out.mp4",
|
|
"videotoolbox",
|
|
);
|
|
expect(args[args.indexOf("-vf") + 1]).toBe(SDR_CAPTURE_TO_BT709_FILTER);
|
|
});
|
|
|
|
it("pads odd dimensions for 10-bit (yuv420p10le) GPU HDR encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
height: 1081,
|
|
codec: "h265",
|
|
preset: "medium",
|
|
quality: 23,
|
|
useGpu: true,
|
|
pixelFormat: "yuv420p10le",
|
|
hdr: { transfer: "pq" },
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(args[args.indexOf("-vf") + 1]).toBe(
|
|
"setparams=color_primaries=bt2020:color_trc=smpte2084:colorspace=bt2020nc:range=tv,pad=ceil(iw/2)*2:ceil(ih/2)*2",
|
|
);
|
|
});
|
|
|
|
it("converts alpha ProRes to BT.709 without an even-dim pad", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "prores",
|
|
preset: "4",
|
|
quality: 23,
|
|
pixelFormat: "yuva444p10le",
|
|
},
|
|
inputArgs,
|
|
"out.mov",
|
|
);
|
|
expect(args[args.indexOf("-vf") + 1]).toBe(SDR_RGB_TO_TAGGED_BT709_FILTER);
|
|
expect(args.join(" ")).not.toContain("pad=");
|
|
});
|
|
|
|
it("does not add color metadata for VP9", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "vp9", preset: "good", quality: 23 },
|
|
inputArgs,
|
|
"out.webm",
|
|
);
|
|
expect(args).not.toContain("-colorspace:v");
|
|
});
|
|
|
|
it("adds video_track_timescale for h264", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args).toContain("-video_track_timescale");
|
|
expect(args[args.indexOf("-video_track_timescale") + 1]).toBe("90000");
|
|
});
|
|
|
|
it("does not add timescale for VP9", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "vp9", preset: "good", quality: 23 },
|
|
inputArgs,
|
|
"out.webm",
|
|
);
|
|
expect(args).not.toContain("-video_track_timescale");
|
|
});
|
|
});
|
|
|
|
describe("getEncoderPreset HDR", () => {
|
|
it("returns h265 with 10-bit for HDR HLG", () => {
|
|
const preset = getEncoderPreset("standard", "mp4", { transfer: "hlg" });
|
|
expect(preset.codec).toBe("h265");
|
|
expect(preset.pixelFormat).toBe("yuv420p10le");
|
|
expect(preset.hdr).toEqual({ transfer: "hlg" });
|
|
});
|
|
|
|
it("returns h265 with 10-bit for HDR PQ", () => {
|
|
const preset = getEncoderPreset("high", "mp4", { transfer: "pq" });
|
|
expect(preset.codec).toBe("h265");
|
|
expect(preset.pixelFormat).toBe("yuv420p10le");
|
|
expect(preset.hdr).toEqual({ transfer: "pq" });
|
|
});
|
|
|
|
it("avoids ultrafast preset for HDR (upgrades to fast)", () => {
|
|
const preset = getEncoderPreset("draft", "mp4", { transfer: "hlg" });
|
|
expect(preset.preset).toBe("fast");
|
|
});
|
|
|
|
it("ignores HDR for webm format", () => {
|
|
const preset = getEncoderPreset("standard", "webm", { transfer: "hlg" });
|
|
expect(preset.codec).toBe("vp9");
|
|
expect(preset.hdr).toBeUndefined();
|
|
});
|
|
|
|
it("ignores HDR for mov format", () => {
|
|
const preset = getEncoderPreset("standard", "mov", { transfer: "pq" });
|
|
expect(preset.codec).toBe("prores");
|
|
expect(preset.hdr).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("buildEncoderArgs lockGopForChunkConcat", () => {
|
|
const baseOptions = { fps: { num: 30, den: 1 }, width: 1920, height: 1080 };
|
|
const inputArgs = ["-framerate", "30", "-i", "frames/%04d.png"];
|
|
|
|
// Default path must emit zero closed-GOP args — in-process renders rely on
|
|
// libx264/libx265 defaults to stay byte-identical with their PSNR baselines.
|
|
it("default (false) omits closed-GOP args for libx264", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args).not.toContain("-g");
|
|
expect(args).not.toContain("-keyint_min");
|
|
expect(args).not.toContain("-force_key_frames");
|
|
expect(args).not.toContain("-sc_threshold");
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).not.toContain("scenecut=0");
|
|
expect(args[paramIdx + 1]).not.toContain("open-gop=0");
|
|
expect(args[paramIdx + 1]).not.toContain("repeat-headers=1");
|
|
});
|
|
|
|
it("default (false) omits closed-GOP args for libx265", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args).not.toContain("-g");
|
|
expect(args).not.toContain("-keyint_min");
|
|
expect(args).not.toContain("-force_key_frames");
|
|
expect(args).not.toContain("-sc_threshold");
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).not.toContain("scenecut=0");
|
|
expect(args[paramIdx + 1]).not.toContain("keyint=");
|
|
expect(args[paramIdx + 1]).not.toContain("open-gop=0");
|
|
expect(args[paramIdx + 1]).not.toContain("repeat-headers=1");
|
|
});
|
|
|
|
it("true appends closed-GOP ffmpeg flags and x264-params for libx264", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h264",
|
|
preset: "medium",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-g") + 1]).toBe("240");
|
|
expect(args[args.indexOf("-keyint_min") + 1]).toBe("240");
|
|
expect(args[args.indexOf("-sc_threshold") + 1]).toBe("0");
|
|
expect(args[args.indexOf("-force_key_frames") + 1]).toBe("expr:eq(mod(n,240),0)");
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).toContain("scenecut=0");
|
|
expect(args[paramIdx + 1]).toContain("open-gop=0");
|
|
expect(args[paramIdx + 1]).toContain("repeat-headers=1");
|
|
// -bf 0 was already present for h264; closed-GOP doesn't change that.
|
|
expect(args).toContain("-bf");
|
|
expect(args[args.indexOf("-bf") + 1]).toBe("0");
|
|
// 90000 timescale is required for clean concat-copy — already enforced for h264/h265.
|
|
expect(args[args.indexOf("-video_track_timescale") + 1]).toBe("90000");
|
|
});
|
|
|
|
it("true appends closed-GOP x265-params keyint controls for libx265", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h265",
|
|
preset: "medium",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 360,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-g") + 1]).toBe("360");
|
|
expect(args[args.indexOf("-keyint_min") + 1]).toBe("360");
|
|
expect(args[args.indexOf("-sc_threshold") + 1]).toBe("0");
|
|
expect(args[args.indexOf("-force_key_frames") + 1]).toBe("expr:eq(mod(n,360),0)");
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("keyint=360");
|
|
expect(args[paramIdx + 1]).toContain("min-keyint=360");
|
|
expect(args[paramIdx + 1]).toContain("scenecut=0");
|
|
expect(args[paramIdx + 1]).toContain("open-gop=0");
|
|
expect(args[paramIdx + 1]).toContain("repeat-headers=1");
|
|
// h265 normally tolerates B-frames; closed-GOP concat-copy doesn't.
|
|
expect(args[args.indexOf("-bf") + 1]).toBe("0");
|
|
});
|
|
|
|
it("true preserves the x264-params anti-banding controls", () => {
|
|
// The closed-GOP params join onto the existing aq-mode/deblock string —
|
|
// make sure we didn't accidentally drop the anti-banding tuning.
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h264",
|
|
preset: "medium",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).toContain("aq-mode=3");
|
|
expect(args[paramIdx + 1]).toContain("aq-strength=0.8");
|
|
expect(args[paramIdx + 1]).toContain("deblock=1,1");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt709");
|
|
});
|
|
|
|
it("true with ultrafast preset still emits closed-GOP params and skips deblock", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h264",
|
|
preset: "ultrafast",
|
|
quality: 28,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-g") + 1]).toBe("240");
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).toContain("aq-mode=3");
|
|
expect(args[paramIdx + 1]).toContain("scenecut=0");
|
|
expect(args[paramIdx + 1]).not.toContain("deblock");
|
|
});
|
|
|
|
it("true is a no-op on GPU encoders", () => {
|
|
// GPU encoders take a separate code path; lockGopForChunkConcat does not
|
|
// wire `-g` / `-keyint_min` into nvenc/amf/qsv/vaapi.
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h264",
|
|
preset: "medium",
|
|
quality: 23,
|
|
useGpu: true,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(args).not.toContain("-g");
|
|
expect(args).not.toContain("-keyint_min");
|
|
expect(args).not.toContain("-force_key_frames");
|
|
expect(args).not.toContain("-sc_threshold");
|
|
expect(args.indexOf("-x264-params")).toBe(-1);
|
|
});
|
|
|
|
it("true appends closed-GOP args for libvpx-vp9", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "vp9",
|
|
preset: "good",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.webm",
|
|
);
|
|
expect(args[args.indexOf("-g") + 1]).toBe("240");
|
|
expect(args[args.indexOf("-keyint_min") + 1]).toBe("240");
|
|
expect(args[args.indexOf("-auto-alt-ref") + 1]).toBe("0");
|
|
expect(args[args.indexOf("-cpu-used") + 1]).toBe("4");
|
|
expect(args[args.indexOf("-deadline") + 1]).toBe("good");
|
|
expect(args.indexOf("-x264-params")).toBe(-1);
|
|
expect(args.indexOf("-x265-params")).toBe(-1);
|
|
expect(args.indexOf("-sc_threshold")).toBe(-1);
|
|
expect(args.indexOf("-force_key_frames")).toBe(-1);
|
|
});
|
|
|
|
it("default (false) omits closed-GOP args for libvpx-vp9", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "vp9", preset: "good", quality: 23 },
|
|
inputArgs,
|
|
"out.webm",
|
|
);
|
|
expect(args).not.toContain("-g");
|
|
expect(args).not.toContain("-keyint_min");
|
|
expect(args[args.indexOf("-cpu-used") + 1]).toBe("4");
|
|
// The non-locked, non-alpha VP9 path leaves `-auto-alt-ref` at the
|
|
// libvpx default. Alpha branches still emit `-auto-alt-ref 0` for an
|
|
// unrelated reason (alpha + alt-ref is unsupported), but that's a
|
|
// separate test below.
|
|
expect(args).not.toContain("-auto-alt-ref");
|
|
});
|
|
|
|
it("honors the resolved engine VP9 cpu-used override", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "vp9", preset: "good", quality: 23, vp9CpuUsed: 6 },
|
|
inputArgs,
|
|
"out.webm",
|
|
);
|
|
|
|
expect(args[args.indexOf("-cpu-used") + 1]).toBe("6");
|
|
});
|
|
|
|
it("true with alpha pixel format keeps alpha metadata and emits -auto-alt-ref once", () => {
|
|
// Regression: alpha + closed-GOP must NOT double-push `-auto-alt-ref 0`.
|
|
// Both paths want it disabled; the encoder branch emits it exactly once.
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "vp9",
|
|
preset: "good",
|
|
quality: 23,
|
|
pixelFormat: "yuva420p",
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.webm",
|
|
);
|
|
const autoAltRefIndices = args.reduce<number[]>((acc, a, i) => {
|
|
if (a === "-auto-alt-ref") acc.push(i);
|
|
return acc;
|
|
}, []);
|
|
expect(autoAltRefIndices.length).toBe(1);
|
|
expect(args[autoAltRefIndices[0] + 1]).toBe("0");
|
|
expect(args[args.indexOf("-metadata:s:v:0") + 1]).toBe("alpha_mode=1");
|
|
expect(args[args.indexOf("-g") + 1]).toBe("240");
|
|
});
|
|
|
|
it("vp9 + lockGopForChunkConcat=true throws on missing gopSize", () => {
|
|
// Mirrors the libx264/libx265 branch: closed-GOP without a GOP size
|
|
// makes no sense — surface the caller error eagerly.
|
|
expect(() =>
|
|
buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "vp9",
|
|
preset: "good",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
},
|
|
inputArgs,
|
|
"out.webm",
|
|
),
|
|
).toThrow(/lockGopForChunkConcat=true requires a positive integer gopSize/);
|
|
});
|
|
|
|
it("resolveLockedGopSize floors, passes through null, and rejects bad sizes", () => {
|
|
expect(resolveLockedGopSize({})).toBeNull();
|
|
expect(resolveLockedGopSize({ gopSize: 120 })).toBeNull();
|
|
expect(resolveLockedGopSize({ lockGopForChunkConcat: true, gopSize: 120.7 })).toBe(120);
|
|
for (const bad of [undefined, 0, -10, NaN, Infinity]) {
|
|
expect(() =>
|
|
resolveLockedGopSize({ lockGopForChunkConcat: true, gopSize: bad as number | undefined }),
|
|
).toThrow(/lockGopForChunkConcat=true requires a positive integer gopSize/);
|
|
}
|
|
});
|
|
|
|
it("appendLockedGopArgs emits the closed-GOP quartet in order", () => {
|
|
const args: string[] = [];
|
|
appendLockedGopArgs(args, 120);
|
|
expect(args).toEqual([
|
|
"-g",
|
|
"120",
|
|
"-keyint_min",
|
|
"120",
|
|
"-sc_threshold",
|
|
"0",
|
|
"-force_key_frames",
|
|
"expr:eq(mod(n,120),0)",
|
|
]);
|
|
});
|
|
|
|
it("lockedGopCodecParams adds keyint only for h265", () => {
|
|
expect(lockedGopCodecParams("h264", 120)).toBe("scenecut=0:open-gop=0:repeat-headers=1");
|
|
expect(lockedGopCodecParams("h265", 120)).toBe(
|
|
"keyint=120:min-keyint=120:scenecut=0:open-gop=0:repeat-headers=1",
|
|
);
|
|
});
|
|
|
|
it("true is a no-op on ProRes (intra-only — no GOP forcing needed)", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "prores",
|
|
preset: "4444",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.mov",
|
|
);
|
|
expect(args).not.toContain("-g");
|
|
expect(args).not.toContain("-keyint_min");
|
|
expect(args).not.toContain("-force_key_frames");
|
|
});
|
|
|
|
it("true with missing or invalid gopSize throws", () => {
|
|
for (const bad of [undefined, 0, -10, NaN, Infinity]) {
|
|
expect(() =>
|
|
buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h264",
|
|
preset: "medium",
|
|
quality: 23,
|
|
lockGopForChunkConcat: true,
|
|
gopSize: bad as number | undefined,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
),
|
|
).toThrow(/lockGopForChunkConcat=true requires a positive integer gopSize/);
|
|
}
|
|
});
|
|
|
|
it("HDR + closed-GOP keeps HDR mastering metadata in x265-params", () => {
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h265",
|
|
preset: "medium",
|
|
quality: 23,
|
|
hdr: { transfer: "pq" },
|
|
lockGopForChunkConcat: true,
|
|
gopSize: 240,
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt2020");
|
|
expect(args[paramIdx + 1]).toContain("transfer=smpte2084");
|
|
expect(args[paramIdx + 1]).toContain("master-display=");
|
|
expect(args[paramIdx + 1]).toContain("max-cll=");
|
|
expect(args[paramIdx + 1]).toContain("keyint=240");
|
|
expect(args[paramIdx + 1]).toContain("scenecut=0");
|
|
});
|
|
});
|
|
|
|
describe("buildEncoderArgs HDR color space", () => {
|
|
const baseOptions = { fps: { num: 30, den: 1 }, width: 1920, height: 1080 };
|
|
const inputArgs = ["-framerate", "30", "-i", "frames/%04d.png"];
|
|
|
|
it("emits BT.2020 + arib-std-b67 tags for HDR HLG (h265 SW)", () => {
|
|
// When options.hdr is set, the caller asserts the input pixels are
|
|
// already in the BT.2020 color space — tag the output truthfully so
|
|
// HDR-aware players apply the right transform.
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23, hdr: { transfer: "hlg" } },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt2020nc");
|
|
expect(args[args.indexOf("-color_primaries:v") + 1]).toBe("bt2020");
|
|
expect(args[args.indexOf("-color_trc:v") + 1]).toBe("arib-std-b67");
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt2020");
|
|
expect(args[paramIdx + 1]).toContain("transfer=arib-std-b67");
|
|
expect(args[paramIdx + 1]).toContain("colormatrix=bt2020nc");
|
|
});
|
|
|
|
it("emits BT.2020 + smpte2084 tags for HDR PQ (h265 SW)", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23, hdr: { transfer: "pq" } },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt2020nc");
|
|
expect(args[args.indexOf("-color_primaries:v") + 1]).toBe("bt2020");
|
|
expect(args[args.indexOf("-color_trc:v") + 1]).toBe("smpte2084");
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt2020");
|
|
expect(args[paramIdx + 1]).toContain("transfer=smpte2084");
|
|
expect(args[paramIdx + 1]).toContain("colormatrix=bt2020nc");
|
|
});
|
|
|
|
it("embeds HDR static mastering metadata in x265-params when HDR is set", () => {
|
|
// master-display + max-cll SEI messages are required so HDR-aware
|
|
// players (Apple QuickTime, YouTube, HDR TVs) treat the stream as
|
|
// HDR10 instead of falling back to SDR BT.2020 tone-mapping.
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23, hdr: { transfer: "pq" } },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("master-display=");
|
|
expect(args[paramIdx + 1]).toContain("max-cll=");
|
|
});
|
|
|
|
it("uses bt709 when HDR is not set (SDR Chrome captures)", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_trc:v") + 1]).toBe("bt709");
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt709");
|
|
expect(args[paramIdx + 1]).not.toContain("master-display");
|
|
});
|
|
|
|
it("does not embed HDR mastering metadata when HDR is not set", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x265-params");
|
|
expect(args[paramIdx + 1]).not.toContain("master-display");
|
|
expect(args[paramIdx + 1]).not.toContain("max-cll");
|
|
});
|
|
|
|
it("strips HDR and tags as SDR/BT.709 when codec=h264 (libx264 has no HDR support)", () => {
|
|
// libx264 cannot encode HDR. Rather than emit a "half-HDR" file (BT.2020
|
|
// container tags + BT.709 VUI inside the bitstream — confusing to HDR-aware
|
|
// players), we strip hdr and tag the whole output as SDR/BT.709. The caller
|
|
// gets a warning telling them to use codec=h265 for real HDR output.
|
|
const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23, hdr: { transfer: "pq" } },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const paramIdx = args.indexOf("-x264-params");
|
|
expect(args[paramIdx + 1]).toContain("colorprim=bt709");
|
|
expect(args[paramIdx + 1]).not.toContain("master-display");
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_primaries:v") + 1]).toBe("bt709");
|
|
expect(args[args.indexOf("-color_trc:v") + 1]).toBe("bt709");
|
|
expect(warnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining("HDR is not supported with codec=h264"),
|
|
);
|
|
warnSpy.mockRestore();
|
|
});
|
|
|
|
it("uses range conversion for HDR CPU encoding", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h265", preset: "medium", quality: 23, hdr: { transfer: "hlg" } },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const vfIdx = args.indexOf("-vf");
|
|
expect(vfIdx).toBeGreaterThan(-1);
|
|
expect(args[vfIdx + 1]).toContain("scale=in_range=pc:out_range=tv");
|
|
});
|
|
|
|
it("converts SDR CPU captures to the BT.709 matrix", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...baseOptions, codec: "h264", preset: "medium", quality: 23 },
|
|
inputArgs,
|
|
"out.mp4",
|
|
);
|
|
const vfIdx = args.indexOf("-vf");
|
|
expect(args[vfIdx + 1]).toBe(SDR_CAPTURE_TO_BT709_FILTER);
|
|
});
|
|
|
|
it("tags BT.2020 + transfer for HDR GPU H.265 (no mastering metadata via -x265-params)", () => {
|
|
// GPU encoders (nvenc, videotoolbox, amf, qsv, vaapi) still emit the BT.2020
|
|
// color tags via the codec-level -colorspace/-color_primaries/-color_trc
|
|
// flags, but cannot accept x265-params, so HDR static mastering metadata
|
|
// (master-display, max-cll) is not embedded. Acceptable for previews,
|
|
// not for HDR-aware delivery.
|
|
const args = buildEncoderArgs(
|
|
{
|
|
...baseOptions,
|
|
codec: "h265",
|
|
preset: "medium",
|
|
quality: 23,
|
|
useGpu: true,
|
|
hdr: { transfer: "pq" },
|
|
},
|
|
inputArgs,
|
|
"out.mp4",
|
|
"nvenc",
|
|
);
|
|
expect(args[args.indexOf("-colorspace:v") + 1]).toBe("bt2020nc");
|
|
expect(args[args.indexOf("-color_primaries:v") + 1]).toBe("bt2020");
|
|
expect(args[args.indexOf("-color_trc:v") + 1]).toBe("smpte2084");
|
|
expect(args.indexOf("-x265-params")).toBe(-1);
|
|
});
|
|
});
|
|
|
|
describe("buildConcatArgs", () => {
|
|
it("stream-copies the concat list and writes provenance before the output", () => {
|
|
const args = buildConcatArgs("/w/concat-list.txt", "/w/video-only.mp4");
|
|
expect(args.slice(0, 8)).toEqual([
|
|
"-f",
|
|
"concat",
|
|
"-safe",
|
|
"0",
|
|
"-i",
|
|
"/w/concat-list.txt",
|
|
"-c",
|
|
"copy",
|
|
]);
|
|
// Provenance must land between the copy flags and the output path: the
|
|
// concat demuxer drops the per-chunk container metadata, so this file is
|
|
// the only place it can be re-asserted.
|
|
expect(args).toEqual(expect.arrayContaining(renderProvenanceArgs("/w/video-only.mp4")));
|
|
expect(args.at(-2)).toBe("-y");
|
|
expect(args.at(-1)).toBe("/w/video-only.mp4");
|
|
});
|
|
});
|
|
|
|
describe.skipIf(!HAS_FFMPEG)("buildEncoderArgs SDR colour", () => {
|
|
const ffmpeg = getFfmpegBinary();
|
|
const pixelAt = (file: string, decode: string, x: number, format = "rgb24"): number[] => [
|
|
...spawnSync(ffmpeg, [
|
|
"-v",
|
|
"error",
|
|
"-i",
|
|
file,
|
|
"-vf",
|
|
`${decode}format=${format},crop=1:1:${x}:8`,
|
|
"-frames:v",
|
|
"1",
|
|
"-f",
|
|
"rawvideo",
|
|
"-",
|
|
]).stdout,
|
|
];
|
|
|
|
// Chrome captures are BT.601 JPEGs. A direct YUV-to-YUV scale keeps that matrix under the BT.709
|
|
// tag (ffmpeg 7 and older) or tints greys (8 and newer), so the encode goes through RGB.
|
|
it("delivers Chrome's JPEG colours in the BT.709 the mp4 is tagged with", () => {
|
|
const dir = mkdtempSync(join(tmpdir(), "hf-sdr-colour-"));
|
|
try {
|
|
for (const color of ["0xC83C28", "0xFE0000", "0x101010", "0x2050E0"]) {
|
|
const jpg = join(dir, "frame.jpg");
|
|
const out = join(dir, "out.mp4");
|
|
const synth = spawnSync(ffmpeg, [
|
|
"-v",
|
|
"error",
|
|
"-y",
|
|
"-f",
|
|
"lavfi",
|
|
"-i",
|
|
`color=c=${color}:s=64x16,format=rgb24,drawbox=x=31:y=0:w=33:h=16:c=0x0000FE:t=fill`,
|
|
"-frames:v",
|
|
"1",
|
|
"-pix_fmt",
|
|
"yuvj420p",
|
|
jpg,
|
|
]);
|
|
expect(synth.status).toBe(0);
|
|
const args = buildEncoderArgs(
|
|
{
|
|
fps: { num: 30, den: 1 },
|
|
width: 64,
|
|
height: 16,
|
|
codec: "h264",
|
|
preset: "ultrafast",
|
|
quality: 0,
|
|
},
|
|
["-i", jpg],
|
|
out,
|
|
);
|
|
expect(spawnSync(ffmpeg, args).status).toBe(0);
|
|
|
|
// x=8 is flat colour; x=32 sits one pixel inside the blue edge, where a smoothing
|
|
// chroma resample bleeds the colour across.
|
|
for (const [x, limit] of [
|
|
[8, 2],
|
|
[32, 2],
|
|
] as const) {
|
|
const captured = pixelAt(jpg, "", x);
|
|
const delivered = pixelAt(out, "scale=in_color_matrix=bt709:in_range=tv,", x);
|
|
const worst = Math.max(...delivered.map((v, i) => Math.abs(v - captured[i]!)));
|
|
expect(
|
|
worst,
|
|
`${color} x=${x}: capture ${captured} delivered ${delivered}`,
|
|
).toBeLessThanOrEqual(limit);
|
|
}
|
|
}
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
}, 30_000);
|
|
|
|
// VideoToolbox, like a libx264/libx265 given no colour options, writes only the colour its frames carry.
|
|
const streamTagsThrough = (args: string[], encoder: string[]): string => {
|
|
const dir = mkdtempSync(join(tmpdir(), "hf-frame-tags-"));
|
|
try {
|
|
const out = join(dir, "out.mp4");
|
|
const vfAt = args.indexOf("-vf");
|
|
const vf = vfAt === -1 ? [] : ["-vf", args[vfAt + 1]!];
|
|
const source = ["-f", "lavfi", "-i", "color=c=0x808080:s=64x16:d=0.1"];
|
|
const encode = spawnSync(ffmpeg, ["-y", "-v", "error", ...source, ...vf, ...encoder, out]);
|
|
expect(encode.status).toBe(0);
|
|
const entries = "stream=color_space,color_transfer,color_primaries";
|
|
const probe = ["-v", "error", "-show_entries", entries, "-of", "csv=p=0", "--", out];
|
|
return spawnSync(getFfprobeBinary(), probe).stdout.toString().trim();
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
};
|
|
const tinyFrame = { fps: { num: 30, den: 1 }, width: 64, height: 16, preset: "ultrafast" };
|
|
|
|
it("tags BT.709 on the frames, so an encoder that reads only them tags the stream", () => {
|
|
const args = buildEncoderArgs(
|
|
{ ...tinyFrame, codec: "h264", quality: 23 },
|
|
["-i", "in"],
|
|
"o.mp4",
|
|
);
|
|
|
|
expect(streamTagsThrough(args, ["-c:v", "libx264", "-preset", "ultrafast"])).toBe(
|
|
"bt709,bt709,bt709",
|
|
);
|
|
});
|
|
|
|
it.each([
|
|
["pq", "smpte2084", null],
|
|
["hlg", "arib-std-b67", null],
|
|
["pq", "smpte2084", "videotoolbox"],
|
|
] as const)("tags HDR %s (%s) on the frames for encoder %s", (transfer, trc, gpu) => {
|
|
const args = buildEncoderArgs(
|
|
{ ...tinyFrame, codec: "h265", quality: 23, hdr: { transfer }, useGpu: gpu !== null },
|
|
["-i", "in"],
|
|
"o.mp4",
|
|
gpu,
|
|
);
|
|
const x265 = ["-c:v", "libx265", "-pix_fmt", "yuv420p10le", "-x265-params", "log-level=error"];
|
|
|
|
expect(streamTagsThrough(args, x265)).toBe(`bt2020nc,${trc},bt2020`);
|
|
});
|
|
|
|
it("keeps the rightmost 8 columns of a 1080-wide (16n + 8) mp4", () => {
|
|
const dir = mkdtempSync(join(tmpdir(), "hf-sdr-right-edge-"));
|
|
try {
|
|
const jpg = join(dir, "frame.jpg");
|
|
const out = join(dir, "out.mp4");
|
|
const synth = spawnSync(ffmpeg, [
|
|
"-v",
|
|
"error",
|
|
"-y",
|
|
"-f",
|
|
"lavfi",
|
|
"-i",
|
|
"color=c=0xC83C28:s=1080x16,format=rgb24",
|
|
"-frames:v",
|
|
"1",
|
|
"-pix_fmt",
|
|
"yuvj420p",
|
|
jpg,
|
|
]);
|
|
expect(synth.status).toBe(0);
|
|
const args = buildEncoderArgs(
|
|
{
|
|
fps: { num: 30, den: 1 },
|
|
width: 1080,
|
|
height: 16,
|
|
codec: "h264",
|
|
preset: "ultrafast",
|
|
quality: 0,
|
|
},
|
|
["-i", jpg],
|
|
out,
|
|
);
|
|
expect(spawnSync(ffmpeg, args).status).toBe(0);
|
|
for (const x of [1071, 1075, 1079]) {
|
|
const captured = pixelAt(jpg, "", x);
|
|
const delivered = pixelAt(out, "scale=in_color_matrix=bt709:in_range=tv,", x);
|
|
const worst = Math.max(...delivered.map((v, i) => Math.abs(v - captured[i]!)));
|
|
expect(worst, `x=${x}: capture ${captured} delivered ${delivered}`).toBeLessThanOrEqual(2);
|
|
}
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
}, 30_000);
|
|
|
|
// Untagged HD reads as BT.709 in QuickTime, so ProRes has to be BT.709 too. MOV captures are
|
|
// RGBA PNGs, and the conversion must leave their alpha plane alone. The tags come from
|
|
// setparams because prores_ks ignores -color_* (ffmpeg 5.1 writes none, 8.1 only the matrix).
|
|
it("delivers PNG colours and alpha in the BT.709 the ProRes mov is tagged with", () => {
|
|
const dir = mkdtempSync(join(tmpdir(), "hf-prores-colour-"));
|
|
const png = join(dir, "frame.png");
|
|
const out = join(dir, "out.mov");
|
|
try {
|
|
for (const color of ["0xC83C28", "0x00FF00", "0x101010"]) {
|
|
const synth = spawnSync(ffmpeg, [
|
|
"-v",
|
|
"error",
|
|
"-y",
|
|
"-f",
|
|
"lavfi",
|
|
"-i",
|
|
`color=c=${color}@0.5:s=64x16,format=rgba`,
|
|
"-frames:v",
|
|
"1",
|
|
png,
|
|
]);
|
|
expect(synth.status).toBe(0);
|
|
const args = buildEncoderArgs(
|
|
{
|
|
fps: { num: 30, den: 1 },
|
|
width: 64,
|
|
height: 16,
|
|
codec: "prores",
|
|
preset: "4444",
|
|
quality: 23,
|
|
pixelFormat: "yuva444p10le",
|
|
},
|
|
["-i", png],
|
|
out,
|
|
);
|
|
expect(spawnSync(ffmpeg, args).status).toBe(0);
|
|
|
|
const captured = pixelAt(png, "", 8, "rgba");
|
|
const delivered = pixelAt(out, "scale=in_color_matrix=bt709:in_range=tv,", 8, "rgba");
|
|
const worst = Math.max(...delivered.map((v, i) => Math.abs(v - captured[i]!)));
|
|
expect(worst, `${color}: capture ${captured} delivered ${delivered}`).toBeLessThanOrEqual(
|
|
2,
|
|
);
|
|
}
|
|
// Read the first frame, not the stream: a prores_ks mov's stream-level range depends on
|
|
// the ffprobe version (7.1 and 8.0 report unknown), while every version tags the frames.
|
|
const tags = spawnSync(getFfprobeBinary(), [
|
|
"-v",
|
|
"error",
|
|
"-select_streams",
|
|
"v:0",
|
|
"-read_intervals",
|
|
"%+#1",
|
|
"-show_entries",
|
|
"frame=color_range,color_space,color_primaries,color_transfer",
|
|
"-of",
|
|
"csv=p=0",
|
|
"--",
|
|
out,
|
|
]);
|
|
expect(tags.stdout.toString().trim()).toBe("tv,bt709,bt709,bt709");
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
}, 30_000);
|
|
});
|