mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-19 11:26:02 +00:00
* fix(producer): resume checks the segment file the join reads, not the manifest's path A resumed segmented render now validates each reusable segment at its own computed path in the segment folder. It must be a plain file, not a link, and match a slice of this render's plan. The path a manifest records is never opened or probed. * fix(engine,producer): concat joins open only the list and encoder containers Both concat-demuxer joins (the engine's chunk and segment concat and the distributed assemble join) now pass a format whitelist of concat, mov and matroska. ffmpeg applies it to every file the list opens, so a listed file that is a playlist or manifest cannot pull in other files, while mp4, mov and webm joins work as before. * fix(producer): resume reuses only segments this install recorded Segment manifests are now signed with an HMAC keyed by a per-install secret kept in the HyperFrames config folder, outside every project. Resume trusts a manifest only when its signature checks out, so a segment folder copied from another machine or shipped inside a project is captured again, while a render's own interrupted run resumes as before. * docs(producer): restore the segment path ordering comment and rewrap resume docs * fix(producer): replace an empty or short resume key file A key file too short to use is now replaced by a fresh key instead of disabling resume for good. A missing key is still linked into place, so renders that create it at the same time share one key; a test runs eight processes against one path to check that. * fix(producer): warn under --resume when no resume key is available When the resume key can be neither read nor created, for example on a read-only home folder, a file system without hard links or a serverless runtime, --resume now logs one warning that every segment will be captured again instead of only reporting zero complete segments. * fix(engine): fail a concat join at a list entry ffmpeg refuses The concat demuxer ends the stream at a listed file it cannot open and ffmpeg still exits 0, which cut the output short without an error. -xerror on the concat input makes the join fail instead. mp4, mov and webm joins still exit 0. * fix(producer): resume checks each reused segment's SHA-256 Each finished segment's SHA-256 is now recorded in the signed manifest. The hash is taken once when the segment closes, and on resume only the files about to be reused are hashed again, so a file swapped for another of the same size is captured again. * docs(cli): note that resume re-checks segment hashes and recaptures older segments once * fix(studio-server): proxy joins only its own pieces, through the shared concat input Studio's chunked proxy copy now names its pieces with a tag keyed by the user's preview token, so pieces that arrive inside a project folder sit at names it never looks up and every piece is encoded fresh. A stopped copy of the user's own still continues from its finished pieces. The piece join uses concatListInputArgs, now in @hyperframes/parsers so the engine, producer and Studio share it. It allows only local files in the concat, mov or matroska formats and fails at a refused entry. The cache sweep recognizes both tagged and older piece names. * test(parsers): prove the concat protocol whitelist with a data: entry ffmpeg already refuses http:// in a concat list opened from a file, so the test passed without the whitelist. A data: entry opens by default; the test now asserts it is refused as not on the 'file' whitelist. * fix(studio-server): only the copy's own tagged pieces count as lock progress The copy lock counted any .part-<key>- file as the owner's progress, so a piece shipped with a future modified time kept a stalled lock looking active. It now counts only names under the copy's own tagged piece prefix. The cache sweep removes untagged pieces past the usual age even while that copy runs, and measures age in both directions so a future-dated piece is swept too. * fix(studio-server): say once when proxy pieces cannot be keyed to the user Without a preview token, piece names use a per-process secret, so pieces are reused only within that Studio process. Studio now logs that once, so a copy restarting from its first piece after a restart has a visible cause. * test(studio-server): name the proxy join test for what it checks * fix(producer): derive the segment manifest key from the preview token Sign segment manifests with an HMAC key derived from the per-user preview token instead of a separate key file. The token is created with an exclusive open, so concurrent renders never end up with different keys, and it is only used when the file is private to this user. Resume now checks a segment's SHA-256 before probing it, and a real-ffmpeg test documents how the concat join treats an entry that is itself an ffconcat list. * docs(producer): describe the manifest key per user and the no-token case
2363 lines
89 KiB
TypeScript
2363 lines
89 KiB
TypeScript
import { execFileSync, spawn as realSpawn, spawnSync, type ChildProcess } from "node:child_process";
|
|
import { MEDIA_INPUT_ARGS } from "./mediaExtensions.js";
|
|
import os from "node:os";
|
|
import { EventEmitter, once } from "node:events";
|
|
import {
|
|
cpSync,
|
|
existsSync,
|
|
mkdirSync,
|
|
mkdtempSync,
|
|
readdirSync,
|
|
readFileSync,
|
|
realpathSync,
|
|
rmSync,
|
|
symlinkSync,
|
|
utimesSync,
|
|
writeFileSync,
|
|
} from "node:fs";
|
|
import { availableParallelism, tmpdir, totalmem } from "node:os";
|
|
import { basename, dirname, join } from "node:path";
|
|
import { hdrToSdrToneMapFilter } from "@hyperframes/core";
|
|
import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
|
|
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const FFMPEG_PATH = "/usr/bin/ffmpeg";
|
|
const realFfmpeg = findFfBinary("ffmpeg");
|
|
const realFfmpegFilters = realFfmpeg
|
|
? spawnSync(realFfmpeg, ["-hide_banner", "-filters"], { encoding: "utf8" }).stdout
|
|
: "";
|
|
const canToneMapForReal =
|
|
Boolean(findFfBinary("ffprobe")) && /\szscale\s/.test(realFfmpegFilters ?? "");
|
|
const realFfmpegEncoders = realFfmpeg
|
|
? spawnSync(realFfmpeg, ["-hide_banner", "-encoders"], { encoding: "utf8" }).stdout
|
|
: "";
|
|
const canEncodeVpxAlphaForReal =
|
|
Boolean(findFfBinary("ffprobe")) &&
|
|
/\slibvpx\s/.test(realFfmpegEncoders ?? "") &&
|
|
/\slibvpx-vp9\s/.test(realFfmpegEncoders ?? "");
|
|
|
|
function meanLuma(path: string, filters = "", inputArgs: string[] = []): number {
|
|
const stats = execFileSync(
|
|
realFfmpeg!,
|
|
[
|
|
"-v",
|
|
"error",
|
|
...inputArgs,
|
|
"-i",
|
|
path,
|
|
"-frames:v",
|
|
"1",
|
|
"-vf",
|
|
`${filters}signalstats,metadata=print:file=-`,
|
|
"-f",
|
|
"null",
|
|
"-",
|
|
],
|
|
{ encoding: "utf8" },
|
|
);
|
|
return Number(/YAVG=([\d.]+)/.exec(stats)?.[1]);
|
|
}
|
|
|
|
// Mirrors MAX_CONCURRENT_TRANSCODES in proxyTranscoder.ts (not exported —
|
|
// this test file and the module are authored together).
|
|
const MAX_CONCURRENT = 2;
|
|
const MAX_QUEUED = 8;
|
|
// Mirrors PROXY_CHUNK_SECONDS in proxyTranscoder.ts.
|
|
const PIECE_SECONDS = 15;
|
|
|
|
type FakeProc = EventEmitter & {
|
|
stderr: EventEmitter;
|
|
stdout: EventEmitter;
|
|
kill: (signal?: string) => void;
|
|
pid?: number;
|
|
};
|
|
|
|
function createFakeProc(): FakeProc {
|
|
const proc = new EventEmitter() as FakeProc;
|
|
proc.stderr = new EventEmitter();
|
|
proc.stdout = new EventEmitter();
|
|
proc.kill = vi.fn((signal?: string) => void proc.emit("close", null, signal));
|
|
proc.pid = 4242;
|
|
return proc;
|
|
}
|
|
|
|
type SpawnOptions = { windowsHide?: boolean; signal?: AbortSignal };
|
|
type SpawnCall = { command: string; args: string[]; options?: SpawnOptions; proc: FakeProc };
|
|
type SpawnImpl = (command: string, args: string[], options?: SpawnOptions) => FakeProc;
|
|
|
|
function createSpawnSpy(): { spawn: SpawnImpl; calls: SpawnCall[] } {
|
|
const calls: SpawnCall[] = [];
|
|
const spawn: SpawnImpl = (command, args, options) => {
|
|
const proc = createFakeProc();
|
|
calls.push({ command, args, options, proc });
|
|
return proc;
|
|
};
|
|
return { spawn, calls };
|
|
}
|
|
|
|
/** Mimics ffmpeg writing its output file before exiting 0. */
|
|
function succeed(call: SpawnCall, contents = "fake-h264-bytes"): void {
|
|
const outputPath = call.args.at(-1);
|
|
if (!outputPath) throw new Error("spawn call had no output path arg");
|
|
writeFileSync(outputPath, contents);
|
|
call.proc.emit("close", 0);
|
|
}
|
|
|
|
function fail(call: SpawnCall, code = 1, stderr = "boom"): void {
|
|
call.proc.stderr.emit("data", Buffer.from(stderr));
|
|
call.proc.emit("close", code);
|
|
}
|
|
|
|
async function flush(times = 30): Promise<void> {
|
|
for (let i = 0; i < times; i++) await Promise.resolve();
|
|
}
|
|
|
|
/** One more source than the queue can hold, to prove a batch never overflows it. */
|
|
function batchSources(projectDir: string): Array<{ sourcePath: string; variant: "h264" }> {
|
|
return Array.from({ length: MAX_CONCURRENT + MAX_QUEUED + 1 }, (_, i) => {
|
|
const sourcePath = join(projectDir, `batch-${i}.mov`);
|
|
writeFileSync(sourcePath, `source-${i}`);
|
|
return { sourcePath, variant: "h264" };
|
|
});
|
|
}
|
|
|
|
/** Answers every ffmpeg spawn until no new one starts. A finished copy reaches the
|
|
* next spawn through several promise hops, hence the deep flush. */
|
|
async function answerUntilIdle(
|
|
calls: SpawnCall[],
|
|
answer: (call: SpawnCall) => void,
|
|
): Promise<void> {
|
|
for (let done = 0; ; done = calls.length) {
|
|
await flush(50);
|
|
if (calls.length === done) return;
|
|
calls.slice(done).forEach(answer);
|
|
}
|
|
}
|
|
|
|
const tempDirs: string[] = [];
|
|
|
|
/** The copies in a cache folder, leaving out the small index files that find them again. */
|
|
function copiesIn(cacheDir: string): string[] {
|
|
return readdirSync(cacheDir).filter((name) => !/^\.(?:fast|content)-/.test(name));
|
|
}
|
|
|
|
function tmpProject(): string {
|
|
const dir = mkdtempSync(join(tmpdir(), "hf-proxy-transcoder-"));
|
|
tempDirs.push(dir);
|
|
return dir;
|
|
}
|
|
|
|
afterEach(() => {
|
|
for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
|
|
vi.resetModules();
|
|
vi.doUnmock("node:child_process");
|
|
vi.doUnmock("@hyperframes/parsers/ff-binaries");
|
|
delete process.env.HYPERFRAMES_PROXY_MAX_CONCURRENCY;
|
|
delete process.env.HYPERFRAMES_PROXY_MAX_QUEUE;
|
|
});
|
|
|
|
async function loadModule(
|
|
spawn: SpawnImpl,
|
|
ffmpegPath: string | undefined,
|
|
isHdr = false,
|
|
hdrTransfer: string | null = isHdr ? "pq" : null,
|
|
codecName?: string,
|
|
durationSeconds?: number,
|
|
streams?: string[],
|
|
token: string | null = "a".repeat(64),
|
|
): Promise<typeof import("./proxyTranscoder.js")> {
|
|
vi.resetModules();
|
|
vi.doMock("@hyperframes/core/preview-proof", () => ({ previewToken: () => token }));
|
|
vi.doMock("node:child_process", () => {
|
|
const mocked = { spawn };
|
|
return { ...mocked, default: mocked };
|
|
});
|
|
vi.doMock("@hyperframes/parsers/ff-binaries", async (importOriginal) => ({
|
|
...(await importOriginal<typeof import("@hyperframes/parsers/ff-binaries")>()),
|
|
findFfBinary: () => ffmpegPath,
|
|
}));
|
|
vi.doMock("./mediaMetadata.js", () => ({
|
|
probeMediaMetadata: async () => ({
|
|
kind: "video",
|
|
color: { isHdr, hdrTransfer, codecName },
|
|
durationSeconds,
|
|
streams,
|
|
}),
|
|
probeFirstFrameColour: async () => ({}),
|
|
}));
|
|
return import("./proxyTranscoder.js");
|
|
}
|
|
|
|
describe("resolveProxy on a long source", () => {
|
|
// Three pieces: two full ones and a last that takes the remainder.
|
|
const LONG_SECONDS = 3 * PIECE_SECONDS + 5;
|
|
const startsOf = (calls: SpawnCall[]): string[] =>
|
|
calls
|
|
.filter((call) => call.args.includes("-ss"))
|
|
.map((call) => call.args[call.args.indexOf("-ss") + 1]!);
|
|
|
|
it("copies in pieces, and a stopped copy continues from its finished pieces", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath, clearFailedTranscodesForTest } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const cachePath = getProxyCachePath(projectDir, sourcePath);
|
|
const cacheDirectory = join(projectDir, ".transcode-cache");
|
|
|
|
const first = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
succeed(calls[0]!);
|
|
await flush(50);
|
|
calls[1]!.proc.emit("close", null, "SIGKILL");
|
|
expect(await first).toBeInstanceOf(Error);
|
|
expect(startsOf(calls)).toEqual(["0", String(PIECE_SECONDS)]);
|
|
expect(readdirSync(cacheDirectory)).toHaveLength(1);
|
|
|
|
clearFailedTranscodesForTest();
|
|
const heard: Array<{ doneSeconds: number; totalSeconds?: number }> = [];
|
|
const second = resolveProxy(projectDir, sourcePath, "h264", undefined, {
|
|
onProgress: (progress) => heard.push(progress),
|
|
});
|
|
for (let answered = calls.length; ; answered = calls.length) {
|
|
await flush(50);
|
|
if (calls.length === answered) break;
|
|
calls.slice(answered).forEach((call) => succeed(call));
|
|
}
|
|
|
|
expect(await second).toBe(cachePath);
|
|
// Only the pieces that were missing were encoded again; the last one runs to the end.
|
|
expect(startsOf(calls)).toEqual([
|
|
"0",
|
|
String(PIECE_SECONDS),
|
|
String(PIECE_SECONDS),
|
|
String(2 * PIECE_SECONDS),
|
|
]);
|
|
// The retry says at once how much the stopped run left done, then counts on from it.
|
|
expect(heard[0]).toEqual({ doneSeconds: PIECE_SECONDS, totalSeconds: LONG_SECONDS });
|
|
expect(heard.at(-1)).toEqual({ doneSeconds: LONG_SECONDS, totalSeconds: LONG_SECONDS });
|
|
expect(calls.at(-1)!.args).toEqual(expect.arrayContaining(["-f", "concat", "-c", "copy"]));
|
|
expect(copiesIn(cacheDirectory)).toEqual([cachePath.split("/").at(-1)]);
|
|
});
|
|
|
|
const answerAll = async (calls: SpawnCall[]): Promise<void> => {
|
|
for (let answered = 0; ; answered = calls.length) {
|
|
await flush(50);
|
|
if (calls.length === answered) break;
|
|
calls.slice(answered).forEach((call) => succeed(call));
|
|
}
|
|
};
|
|
|
|
it("joins pieces through the shared concat input, which allows only local mp4, mov or webm files", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await answerAll(calls);
|
|
await result;
|
|
const joinArgs = calls.at(-1)!.args;
|
|
expect(joinArgs.slice(1, 14)).toEqual([
|
|
"-xerror",
|
|
"-protocol_whitelist",
|
|
"file",
|
|
"-f",
|
|
"concat",
|
|
"-safe",
|
|
"0",
|
|
"-format_whitelist",
|
|
"concat,mov,matroska",
|
|
"-i",
|
|
expect.stringMatching(/pieces\.txt$/),
|
|
"-c",
|
|
"copy",
|
|
]);
|
|
});
|
|
|
|
it("encodes every piece again when the project shipped pieces at the names it can predict", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const stem = basename(getProxyCachePath(projectDir, sourcePath), ".mp4");
|
|
const cacheDirectory = join(projectDir, ".transcode-cache");
|
|
mkdirSync(cacheDirectory, { recursive: true });
|
|
for (const index of [0, 1, 2]) {
|
|
writeFileSync(join(cacheDirectory, `.part-${stem}-${index}.mp4`), "shipped-playlist");
|
|
}
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await answerAll(calls);
|
|
await result;
|
|
expect(startsOf(calls)).toEqual(["0", String(PIECE_SECONDS), String(2 * PIECE_SECONDS)]);
|
|
});
|
|
|
|
it("continues its own stopped copy after a restart, but not pieces another user made", async () => {
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const stopAfterFirstPiece = async (token: string) => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const mod = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
undefined,
|
|
token,
|
|
);
|
|
const run = mod.resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
succeed(calls[0]!);
|
|
await flush(50);
|
|
calls[1]!.proc.emit("close", null, "SIGKILL");
|
|
expect(await run).toBeInstanceOf(Error);
|
|
};
|
|
const resumeStarts = async (token: string) => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const mod = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
undefined,
|
|
token,
|
|
);
|
|
const run = mod.resolveProxy(projectDir, sourcePath);
|
|
await answerAll(calls);
|
|
await run;
|
|
return startsOf(calls);
|
|
};
|
|
|
|
await stopAfterFirstPiece("a".repeat(64));
|
|
expect(await resumeStarts("b".repeat(64))).toEqual([
|
|
"0",
|
|
String(PIECE_SECONDS),
|
|
String(2 * PIECE_SECONDS),
|
|
]);
|
|
rmSync(join(projectDir, ".transcode-cache"), { recursive: true, force: true });
|
|
await stopAfterFirstPiece("a".repeat(64));
|
|
expect(await resumeStarts("a".repeat(64))).toEqual([
|
|
String(PIECE_SECONDS),
|
|
String(2 * PIECE_SECONDS),
|
|
]);
|
|
});
|
|
|
|
it("warns once when no preview token can be read, and still makes the copy", async () => {
|
|
const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
undefined,
|
|
null,
|
|
);
|
|
const projectDir = tmpProject();
|
|
for (const name of ["one.mov", "two.mov"]) {
|
|
const sourcePath = join(projectDir, name);
|
|
writeFileSync(sourcePath, `source-${name}`);
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await answerAll(calls);
|
|
await result;
|
|
}
|
|
const tokenWarnings = warn.mock.calls.filter(([message]) =>
|
|
String(message).includes("no preview token"),
|
|
);
|
|
expect(tokenWarnings).toHaveLength(1);
|
|
warn.mockRestore();
|
|
});
|
|
|
|
it("copies only the first stretch when asked, as a copy of its own", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath, proxyWindowSeconds } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const window = await proxyWindowSeconds(sourcePath, 5);
|
|
expect(window).toBe(PIECE_SECONDS);
|
|
const windowed = getProxyCachePath(projectDir, sourcePath, "h264", undefined, window);
|
|
expect(windowed).not.toBe(getProxyCachePath(projectDir, sourcePath));
|
|
|
|
const result = resolveProxy(projectDir, sourcePath, "h264", undefined, {
|
|
limitSeconds: window,
|
|
});
|
|
await flush();
|
|
succeed(calls[0]!);
|
|
|
|
expect(await result).toBe(windowed);
|
|
expect(calls).toHaveLength(1);
|
|
expect(
|
|
calls[0]!.args.slice(calls[0]!.args.indexOf("-t"), calls[0]!.args.indexOf("-t") + 2),
|
|
).toEqual(["-t", String(PIECE_SECONDS)]);
|
|
});
|
|
|
|
it("copies the whole source when the stretch saves less than a piece", async () => {
|
|
const { spawn } = createSpawnSpy();
|
|
const { proxyWindowSeconds } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const sourcePath = join(tmpProject(), "long.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
expect(await proxyWindowSeconds(sourcePath, LONG_SECONDS - 10)).toBeUndefined();
|
|
});
|
|
|
|
it("copies alpha pieces side by side, shares the cores out, and counts them together", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.webm");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const cores = availableParallelism();
|
|
const workers = Math.max(1, Math.min(4, cores - 1, Math.floor(totalmem() / (3 * 1024 ** 3))));
|
|
const side = Math.min(workers, 3);
|
|
|
|
const heard: number[] = [];
|
|
const result = resolveProxy(projectDir, sourcePath, "vp8", undefined, {
|
|
onProgress: (progress) => heard.push(progress.doneSeconds),
|
|
});
|
|
await flush(50);
|
|
|
|
expect(calls).toHaveLength(side);
|
|
for (const call of calls) {
|
|
expect(call.args[call.args.indexOf("-threads") + 1]).toBe(
|
|
String(Math.min(4, Math.floor(cores / workers))),
|
|
);
|
|
}
|
|
calls[0]!.proc.stdout.emit("data", Buffer.from("out_time_us=4000000\n"));
|
|
if (side > 1) calls[1]!.proc.stdout.emit("data", Buffer.from("out_time_us=6000000\n"));
|
|
expect(heard.at(-1)).toBe(side > 1 ? 10 : 4);
|
|
await answerUntilIdle(calls, (call) => succeed(call, "fake-vp8-bytes"));
|
|
await result;
|
|
expect(heard.at(-1)).toBe(LONG_SECONDS);
|
|
});
|
|
|
|
it("keeps two alpha copies running together within one cap of pieces", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sources = ["a.webm", "b.webm"].map((name) => join(projectDir, name));
|
|
for (const source of sources) writeFileSync(source, "source-bytes");
|
|
const cap = Math.max(
|
|
1,
|
|
Math.min(4, availableParallelism() - 1, Math.floor(totalmem() / (3 * 1024 ** 3))),
|
|
);
|
|
|
|
const results = sources.map((source) => resolveProxy(projectDir, source, "vp8"));
|
|
await flush(50);
|
|
|
|
expect(calls).toHaveLength(cap);
|
|
await answerUntilIdle(calls, (call) => succeed(call, "fake-vp8-bytes"));
|
|
await Promise.all(results);
|
|
expect(calls.filter((call) => call.args.includes("-ss"))).toHaveLength(6);
|
|
});
|
|
|
|
it("ends the pieces still running when one of them fails, and reports that failure", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
LONG_SECONDS,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "long.webm");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath, "vp8").catch((error: unknown) => error);
|
|
await flush(50);
|
|
fail(calls[0]!, 1, "bad piece");
|
|
await flush(50);
|
|
for (const call of calls.slice(1)) {
|
|
expect(call.options?.signal?.aborted).toBe(true);
|
|
call.proc.kill("SIGKILL");
|
|
}
|
|
expect(String(await result)).toContain("bad piece");
|
|
});
|
|
|
|
it("keeps a short source to one pass", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, false, null, undefined, 20);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "short.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).not.toContain("-ss");
|
|
succeed(calls[0]!);
|
|
await result;
|
|
});
|
|
});
|
|
|
|
describe("resolveProxy", () => {
|
|
it("bounds a caller wait without cancelling the shared transcode promise", async () => {
|
|
const { waitForProxy, ProxyWaitTimeoutError } = await loadModule(
|
|
() => createFakeProc(),
|
|
FFMPEG_PATH,
|
|
);
|
|
let finish!: (value: string) => void;
|
|
const shared = new Promise<string>((resolvePromise) => {
|
|
finish = resolvePromise;
|
|
});
|
|
|
|
await expect(waitForProxy(shared, 1)).rejects.toBeInstanceOf(ProxyWaitTimeoutError);
|
|
finish("eventual-proxy.mp4");
|
|
await expect(shared).resolves.toBe("eventual-proxy.mp4");
|
|
});
|
|
|
|
it("transcodes once on a cache miss and caches via temp+rename", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const expectedCachePath = getProxyCachePath(projectDir, sourcePath);
|
|
const resultPromise = resolveProxy(projectDir, sourcePath);
|
|
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
const call = calls[0]!;
|
|
expect(call.args).toContain("-c:v");
|
|
expect(call.args).toContain("libx264");
|
|
expect(call.args).toContain("-crf");
|
|
expect(call.args).toContain("18");
|
|
expect(call.args).toContain("-preset");
|
|
expect(call.args).toContain("veryfast");
|
|
expect(call.args).toContain("-movflags");
|
|
expect(call.args).toContain("+faststart");
|
|
expect(call.args).toContain("-c:a");
|
|
expect(call.args).toContain("aac");
|
|
expect(call.args.some((a) => a.includes("scale="))).toBe(true);
|
|
expect(call.args).toContain("-pix_fmt");
|
|
expect(call.args).toContain("yuv420p");
|
|
expect(call.args).toContain("-colorspace");
|
|
expect(call.args).toContain("bt709");
|
|
expect(call.args).toContain("-color_primaries");
|
|
expect(call.args).toContain("-color_trc");
|
|
// temp-name-then-rename: the ffmpeg output target is not the final path.
|
|
const outputArg = call.args.at(-1)!;
|
|
expect(outputArg).not.toBe(expectedCachePath);
|
|
expect(existsSync(expectedCachePath)).toBe(false);
|
|
|
|
succeed(call);
|
|
const result = await resultPromise;
|
|
|
|
expect(result).toBe(expectedCachePath);
|
|
expect(existsSync(expectedCachePath)).toBe(true);
|
|
// No leftover temp file next to the final cache entry.
|
|
const cacheDirEntries = copiesIn(join(projectDir, ".transcode-cache"));
|
|
expect(cacheDirEntries).toEqual([expectedCachePath.split("/").at(-1)]);
|
|
});
|
|
|
|
it("names the boxed preview copy resolveProxy writes when given the same box", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "clip.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const box = { width: 1024, height: 724 };
|
|
|
|
const boxedPath = getProxyCachePath(projectDir, sourcePath, "h264", box);
|
|
const resultPromise = resolveProxy(projectDir, sourcePath, "h264", box);
|
|
await flush();
|
|
succeed(calls[0]!);
|
|
|
|
expect(await resultPromise).toBe(boxedPath);
|
|
expect(boxedPath).not.toBe(getProxyCachePath(projectDir, sourcePath, "h264"));
|
|
});
|
|
|
|
it("uses Chromium-compatible VP8 alpha args and a distinct WebM cache path", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "alpha.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const h264Path = getProxyCachePath(projectDir, sourcePath, "h264");
|
|
const vp8Path = getProxyCachePath(projectDir, sourcePath, "vp8");
|
|
const resultPromise = resolveProxy(projectDir, sourcePath, "vp8");
|
|
await flush();
|
|
|
|
expect(vp8Path).not.toBe(h264Path);
|
|
expect(vp8Path).toMatch(/\.webm$/);
|
|
expect(h264Path).toMatch(/\.mp4$/);
|
|
const args = calls[0]!.args;
|
|
expect(args).toContain("libvpx");
|
|
expect(args).not.toContain("libvpx-vp9");
|
|
expect(args).toContain("yuva420p");
|
|
expect(args).toContain("libopus");
|
|
expect(args[args.indexOf("-b:v") + 1]).toBe("0");
|
|
expect(args[args.indexOf("-crf") + 1]).toBe("23");
|
|
expect(args[args.indexOf("-deadline") + 1]).toBe("good");
|
|
expect(args[args.indexOf("-auto-alt-ref") + 1]).toBe("0");
|
|
expect(args[args.indexOf("-metadata:s:v:0") + 1]).toBe("alpha_mode=1");
|
|
expect(args[args.indexOf("-ac") + 1]).toBe("2");
|
|
expect(args).not.toContain("-row-mt");
|
|
expect(args).toContain("-cpu-used");
|
|
expect(args[args.indexOf("-threads") + 1]).toBe(String(Math.min(4, availableParallelism())));
|
|
expect(args).not.toContain("-movflags");
|
|
expect(args).not.toContain("+faststart");
|
|
expect(args[args.indexOf("-vf") + 1]).toContain("format=yuva420p");
|
|
|
|
succeed(calls[0]!, "fake-vp8-bytes");
|
|
await expect(resultPromise).resolves.toBe(vp8Path);
|
|
});
|
|
|
|
it("puts a keyframe every second into a copy, so scrubbing lands close", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "clip.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
|
|
const args = calls[0]!.args;
|
|
expect(args[args.indexOf("-force_key_frames") + 1]).toBe("expr:gte(t,n_forced*1)");
|
|
succeed(calls[0]!);
|
|
await result;
|
|
});
|
|
|
|
it("decodes a VP9 alpha source with libvpx-vp9 so the VP8 proxy keeps its alpha", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, false, null, "vp9");
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "cutout.webm");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const vp8 = resolveProxy(projectDir, sourcePath, "vp8");
|
|
await flush();
|
|
const vp8Args = calls[0]!.args;
|
|
expect(vp8Args.slice(vp8Args.indexOf("-i") - 4, vp8Args.indexOf("-i"))).toEqual([
|
|
"-c:v",
|
|
"libvpx-vp9",
|
|
...MEDIA_INPUT_ARGS,
|
|
]);
|
|
succeed(calls[0]!, "fake-vp8-bytes");
|
|
await vp8;
|
|
|
|
const h264 = resolveProxy(projectDir, sourcePath, "h264");
|
|
await flush();
|
|
expect(calls[1]!.args.slice(0, calls[1]!.args.indexOf("-i"))).not.toContain("-c:v");
|
|
succeed(calls[1]!);
|
|
await h264;
|
|
});
|
|
|
|
it.skipIf(!canEncodeVpxAlphaForReal)(
|
|
"keeps a real VP9 alpha webm transparent through probe, variant and transcode",
|
|
async () => {
|
|
vi.resetModules();
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveProxy } = await import("./proxyTranscoder.js");
|
|
const { probeAssetCodec, proxyVariantFor } = await import("./mediaCodecMap.js");
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "cutout.webm");
|
|
// Left half fully transparent, right half opaque: mean alpha 127.5.
|
|
execFileSync(realFfmpeg!, [
|
|
...["-v", "error", "-f", "lavfi", "-i"],
|
|
"testsrc2=s=64x64:d=0.2,format=rgba,geq=r='r(X,Y)':g='g(X,Y)':b='b(X,Y)':a='if(lt(X,32),0,255)'",
|
|
...["-c:v", "libvpx-vp9", "-pix_fmt", "yuva420p", "-auto-alt-ref", "0"],
|
|
...["-metadata:s:v:0", "alpha_mode=1", sourcePath],
|
|
]);
|
|
|
|
const facts = await probeAssetCodec(sourcePath);
|
|
expect(facts).toMatchObject({ codecName: "vp9", hasAlpha: true });
|
|
const proxyPath = await resolveProxy(projectDir, sourcePath, proxyVariantFor(facts!));
|
|
expect(proxyPath).toMatch(/\.webm$/);
|
|
const meanAlpha = meanLuma(proxyPath, "alphaextract,", ["-c:v", "libvpx"]);
|
|
expect(Math.abs(meanAlpha - 127.5)).toBeLessThan(8);
|
|
},
|
|
60_000,
|
|
);
|
|
|
|
it("returns without spawning on a cache hit", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const cachePath = getProxyCachePath(projectDir, sourcePath);
|
|
const { mkdirSync } = await import("node:fs");
|
|
mkdirSync(join(projectDir, ".transcode-cache"), { recursive: true });
|
|
writeFileSync(cachePath, "already-cached");
|
|
|
|
const result = await resolveProxy(projectDir, sourcePath);
|
|
expect(result).toBe(cachePath);
|
|
expect(calls).toHaveLength(0);
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")(
|
|
"makes the copy again when a link stands at its name, and never returns the link's target",
|
|
async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const outside = join(tmpProject(), "id_rsa");
|
|
writeFileSync(outside, "PRIVATE KEY");
|
|
const cachePath = getProxyCachePath(projectDir, sourcePath);
|
|
mkdirSync(dirname(cachePath), { recursive: true });
|
|
symlinkSync(outside, cachePath);
|
|
|
|
const resultPromise = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
succeed(calls[0]!);
|
|
const result = await resultPromise;
|
|
|
|
expect(readFileSync(result, "utf8")).toBe("fake-h264-bytes");
|
|
expect(readFileSync(outside, "utf8")).toBe("PRIVATE KEY");
|
|
},
|
|
);
|
|
|
|
it("tone-maps HDR input before emitting browser-safe BT.709", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, true);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "hdr.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
|
|
expect(calls[0]!.args).toEqual(["-hide_banner", "-filters"]);
|
|
expect(calls[0]!.options?.windowsHide).toBe(true);
|
|
calls[0]!.proc.stdout.emit(
|
|
"data",
|
|
Buffer.from(" ..C zscale V->V zimg scale\n T.C tonemap V->V tone map\n"),
|
|
);
|
|
calls[0]!.proc.emit("close", 0);
|
|
await flush();
|
|
|
|
const filterIndex = calls[1]!.args.indexOf("-vf");
|
|
const filter = calls[1]!.args[filterIndex + 1];
|
|
expect(filter).toContain("tonemap=");
|
|
expect(filter).toContain("bt709");
|
|
expect(filter).toContain("out_color_matrix=bt709");
|
|
|
|
succeed(calls[1]!);
|
|
await result;
|
|
});
|
|
|
|
it("resizes HDR input to the box before the tone map, so the map runs on the smaller frame", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, true);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "hdr.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath, "h264", { width: 2048, height: 1218 });
|
|
await flush();
|
|
calls[0]!.proc.stdout.emit(
|
|
"data",
|
|
Buffer.from(" ..C zscale V->V zimg\n T.C tonemap V->V tone map\n"),
|
|
);
|
|
calls[0]!.proc.emit("close", 0);
|
|
await flush();
|
|
|
|
const filter = calls[1]!.args[calls[1]!.args.indexOf("-vf") + 1]!;
|
|
expect(filter.indexOf("zscale=w=")).toBeGreaterThanOrEqual(0);
|
|
expect(filter.indexOf("zscale=w=")).toBeLessThan(filter.indexOf("tonemap="));
|
|
expect(filter).toContain("2048/iw");
|
|
succeed(calls[1]!);
|
|
await result;
|
|
});
|
|
|
|
it("tells a listener how far the encode has got, from ffmpeg's own progress lines", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, false, null, undefined, 20);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "progress.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const heard: Array<{ doneSeconds: number; totalSeconds?: number }> = [];
|
|
|
|
const result = resolveProxy(projectDir, sourcePath, "h264", undefined, {
|
|
onProgress: (progress) => heard.push(progress),
|
|
});
|
|
await flush();
|
|
expect(calls[0]!.args).toEqual(expect.arrayContaining(["-progress", "pipe:1"]));
|
|
calls[0]!.proc.stdout.emit("data", Buffer.from("frame=10\nout_time_us=12000000\nprogre"));
|
|
calls[0]!.proc.stdout.emit(
|
|
"data",
|
|
Buffer.from("ss=continue\nout_time_us=18500000\nprogress=continue\n"),
|
|
);
|
|
|
|
expect(heard).toEqual([
|
|
{ doneSeconds: 12, totalSeconds: 20 },
|
|
{ doneSeconds: 18.5, totalSeconds: 20 },
|
|
]);
|
|
succeed(calls[0]!);
|
|
await result;
|
|
});
|
|
|
|
describe("a copy that stops making progress", () => {
|
|
afterEach(() => vi.useRealTimers());
|
|
|
|
it("is ended once it makes no progress for the stall window, not before", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, TRANSCODE_STALL_MS } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
80,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "hung.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await vi.advanceTimersByTimeAsync(0);
|
|
await vi.advanceTimersByTimeAsync(TRANSCODE_STALL_MS - 1);
|
|
expect(calls[0]!.proc.kill).not.toHaveBeenCalled();
|
|
await vi.advanceTimersByTimeAsync(1);
|
|
|
|
expect(calls[0]!.proc.kill).toHaveBeenCalledWith("SIGKILL");
|
|
expect(await result).toEqual(
|
|
expect.objectContaining({ message: expect.stringMatching(/no progress/) }),
|
|
);
|
|
});
|
|
|
|
it("keeps going past the old fifteen minute cap while it moves on", async () => {
|
|
vi.useFakeTimers();
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, TRANSCODE_STALL_MS } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
20,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "slow.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await vi.advanceTimersByTimeAsync(0);
|
|
const step = TRANSCODE_STALL_MS / 2;
|
|
for (let at = 1; at <= (20 * 60_000) / step; at++) {
|
|
await vi.advanceTimersByTimeAsync(step);
|
|
calls[0]!.proc.stdout.emit("data", Buffer.from(`out_time_us=${at * 1_000_000}\n`));
|
|
}
|
|
|
|
expect(calls[0]!.proc.kill).not.toHaveBeenCalled();
|
|
succeed(calls[0]!);
|
|
await result;
|
|
});
|
|
});
|
|
|
|
it("hands the abort signal of a batch to its copies, so a stopped check ends them", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxies } = await loadModule(spawn, FFMPEG_PATH, false, null, undefined, 80);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "stopped.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const stopped = new AbortController();
|
|
|
|
const results = resolveProxies(
|
|
projectDir,
|
|
[{ sourcePath, variant: "h264" }],
|
|
undefined,
|
|
undefined,
|
|
stopped.signal,
|
|
);
|
|
await flush();
|
|
expect(calls[0]!.options?.signal?.aborted).toBe(false);
|
|
stopped.abort();
|
|
await flush();
|
|
|
|
expect(calls[0]!.options?.signal?.aborted).toBe(true);
|
|
calls[0]!.proc.emit("close", null, "SIGKILL");
|
|
expect((await results)[0]!.status).toBe("rejected");
|
|
});
|
|
|
|
it("preserves alpha on HDR-tagged VP8 proxies by bypassing the opaque tonemap chain", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, true);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "hdr-alpha.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath, "vp8");
|
|
await flush();
|
|
|
|
expect(calls).toHaveLength(1);
|
|
const filter = calls[0]!.args[calls[0]!.args.indexOf("-vf") + 1];
|
|
expect(filter).toContain("format=yuva420p");
|
|
expect(filter).not.toContain("tonemap=");
|
|
succeed(calls[0]!, "fake-vp8-alpha-bytes");
|
|
await result;
|
|
});
|
|
|
|
it("rejects HDR proxying with a typed actionable error when ffmpeg lacks zscale", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, FfmpegMissingFilterError } = await loadModule(spawn, FFMPEG_PATH, true);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "hdr.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
|
|
expect(calls[0]!.args).toEqual(["-hide_banner", "-filters"]);
|
|
calls[0]!.proc.stdout.emit("data", Buffer.from(" T.C tonemap V->V tone map\n"));
|
|
calls[0]!.proc.emit("close", 0);
|
|
|
|
await expect(result).rejects.toBeInstanceOf(FfmpegMissingFilterError);
|
|
await expect(result).rejects.toThrow(/zscale.*libzimg/i);
|
|
expect(calls).toHaveLength(1);
|
|
});
|
|
|
|
it("does not tone-map BT.2020 footage without a PQ or HLG transfer, as renders do", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, true, "unknown");
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "bt2020-sdr.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]!.args).toContain("-vf");
|
|
expect(calls[0]!.args[calls[0]!.args.indexOf("-vf") + 1]).not.toContain("tonemap=");
|
|
succeed(calls[0]!);
|
|
await result;
|
|
});
|
|
|
|
it.skipIf(!canToneMapForReal)(
|
|
"tone-maps real HLG footage that tags only its transfer, as renders do",
|
|
async () => {
|
|
vi.resetModules();
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveProxy } = await import("./proxyTranscoder.js");
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "hlg-transfer-only.mp4");
|
|
// Primaries and matrix "unspecified" (2), transfer HLG (18).
|
|
const hlgTransferOnly =
|
|
"h264_metadata=colour_primaries=2:transfer_characteristics=18:matrix_coefficients=2";
|
|
execFileSync(realFfmpeg!, [
|
|
"-v",
|
|
"error",
|
|
"-f",
|
|
"lavfi",
|
|
"-i",
|
|
"testsrc2=s=64x36:d=0.2",
|
|
"-c:v",
|
|
"libx264",
|
|
"-pix_fmt",
|
|
"yuv420p",
|
|
"-bsf:v",
|
|
hlgTransferOnly,
|
|
sourcePath,
|
|
]);
|
|
|
|
const proxyPath = await resolveProxy(projectDir, sourcePath);
|
|
// Reference: the render tone map's RGB, converted with BT.709. Skipping the tone map or
|
|
// converting with BT.601 each moves mean luma by several levels.
|
|
const reference = meanLuma(
|
|
sourcePath,
|
|
`${hdrToSdrToneMapFilter({ colorTransfer: "arib-std-b67" }, { colorTransfer: "arib-std-b67", keyframeTransfers: ["arib-std-b67"] })},format=gbrp,scale=in_range=pc:out_color_matrix=bt709:out_range=tv,format=yuv420p,`,
|
|
);
|
|
expect(Math.abs(meanLuma(proxyPath) - reference)).toBeLessThan(1);
|
|
},
|
|
60_000,
|
|
);
|
|
|
|
it.skipIf(!canToneMapForReal)(
|
|
"tone-maps each frame of a real mixed HLG and PQ stream with its own transfer",
|
|
async () => {
|
|
vi.resetModules();
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveProxy } = await import("./proxyTranscoder.js");
|
|
const projectDir = tmpProject();
|
|
const segment = (transfer: number) =>
|
|
execFileSync(realFfmpeg!, [
|
|
...["-v", "error", "-f", "lavfi", "-i", "testsrc2=s=320x180:r=25:d=0.2"],
|
|
// No B-frames: genpts stamps a raw stream in decode order, so reordered frames get wrong times.
|
|
...["-c:v", "libx264", "-bf", "0", "-pix_fmt", "yuv420p", "-bsf:v"],
|
|
`h264_metadata=colour_primaries=9:transfer_characteristics=${transfer}:matrix_coefficients=9`,
|
|
...["-f", "h264", "-"],
|
|
]);
|
|
const mux = (name: string, stream: Buffer) => {
|
|
const raw = join(projectDir, `${name}.h264`);
|
|
const path = join(projectDir, `${name}.mp4`);
|
|
writeFileSync(raw, stream);
|
|
execFileSync(realFfmpeg!, [
|
|
...["-v", "error", "-fflags", "+genpts", "-r", "25", "-f", "h264", "-i", raw],
|
|
...["-c", "copy", path],
|
|
]);
|
|
return path;
|
|
};
|
|
const pq = segment(16);
|
|
const mixedProxy = await resolveProxy(
|
|
projectDir,
|
|
mux("hlg-then-pq", Buffer.concat([segment(18), pq])),
|
|
);
|
|
const pqProxy = await resolveProxy(projectDir, mux("pq-only", pq));
|
|
|
|
// Frame 5 is the first PQ frame: tone-mapped as PQ it lands near 42 dB, read as HLG near 30.
|
|
const psnrAt = (n: number) => {
|
|
const stats = spawnSync(
|
|
realFfmpeg!,
|
|
[
|
|
...["-i", mixedProxy, "-i", pqProxy, "-lavfi"],
|
|
`[0:v]select=eq(n\\,${n}),setpts=PTS-STARTPTS[a];[1:v]select=eq(n\\,0),setpts=PTS-STARTPTS[b];[a][b]psnr`,
|
|
...["-frames:v", "1", "-f", "null", "-"],
|
|
],
|
|
{ encoding: "utf8" },
|
|
).stderr;
|
|
return Number(/average:([\d.]+)/.exec(stats)?.[1] ?? 0);
|
|
};
|
|
expect(psnrAt(5)).toBeGreaterThan(36);
|
|
},
|
|
60_000,
|
|
);
|
|
|
|
it.skipIf(!realFfmpeg || !findFfBinary("ffprobe"))(
|
|
"makes a preview copy that fills the shown box, never larger than the source",
|
|
async () => {
|
|
vi.resetModules();
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveProxy } = await import("./proxyTranscoder.js");
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "portrait.mp4");
|
|
execFileSync(realFfmpeg!, [
|
|
...["-v", "error", "-f", "lavfi", "-i", "testsrc2=s=1080x1920:d=0.1"],
|
|
...["-c:v", "libx264", "-pix_fmt", "yuv420p", sourcePath],
|
|
]);
|
|
const size = (path: string) =>
|
|
execFileSync(
|
|
findFfBinary("ffprobe")!,
|
|
[
|
|
...["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height"],
|
|
...["-of", "csv=p=0", "--", path],
|
|
],
|
|
{ encoding: "utf8" },
|
|
).trim();
|
|
|
|
// The width side binds: 512/1080 > 724/1920, so the height follows the source's shape.
|
|
const boxed = await resolveProxy(projectDir, sourcePath, "h264", { width: 512, height: 724 });
|
|
expect(size(boxed)).toBe("512,912");
|
|
const roomy = await resolveProxy(projectDir, sourcePath, "h264", {
|
|
width: 2048,
|
|
height: 2048,
|
|
});
|
|
expect(size(roomy)).toBe("1080,1920");
|
|
const full = await resolveProxy(projectDir, sourcePath);
|
|
expect(size(full)).toBe("1080,1920");
|
|
expect(new Set([boxed, roomy, full]).size).toBe(3);
|
|
},
|
|
60_000,
|
|
);
|
|
|
|
it("dedupes two concurrent same-key calls to one spawn", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const p1 = resolveProxy(projectDir, sourcePath);
|
|
const p2 = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
|
|
succeed(calls[0]!);
|
|
const [r1, r2] = await Promise.all([p1, p2]);
|
|
expect(r1).toBe(r2);
|
|
});
|
|
|
|
it("respects the global concurrency bound across distinct keys", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePaths = Array.from({ length: 5 }, (_, i) => {
|
|
const p = join(projectDir, `video-${i}.mov`);
|
|
writeFileSync(p, `source-bytes-${i}`);
|
|
return p;
|
|
});
|
|
|
|
const results = sourcePaths.map((p) => resolveProxy(projectDir, p));
|
|
await flush();
|
|
expect(calls).toHaveLength(MAX_CONCURRENT);
|
|
|
|
succeed(calls[0]!);
|
|
succeed(calls[1]!);
|
|
await flush();
|
|
expect(calls).toHaveLength(4);
|
|
|
|
succeed(calls[2]!);
|
|
succeed(calls[3]!);
|
|
await flush();
|
|
expect(calls).toHaveLength(5);
|
|
|
|
succeed(calls[4]!);
|
|
const resolved = await Promise.all(results);
|
|
expect(new Set(resolved).size).toBe(5);
|
|
// At no point did more than MAX_CONCURRENT spawns run unresolved at once.
|
|
expect(calls.length).toBeLessThanOrEqual(sourcePaths.length);
|
|
});
|
|
|
|
it("rejects excess queued work with a typed capacity error", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxyCapacityError } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePaths = Array.from({ length: MAX_CONCURRENT + MAX_QUEUED + 1 }, (_, i) => {
|
|
const path = join(projectDir, `queued-${i}.mov`);
|
|
writeFileSync(path, `source-${i}`);
|
|
return path;
|
|
});
|
|
|
|
const accepted = sourcePaths.slice(0, -1).map((path) => resolveProxy(projectDir, path));
|
|
await expect(resolveProxy(projectDir, sourcePaths.at(-1)!)).rejects.toBeInstanceOf(
|
|
ProxyCapacityError,
|
|
);
|
|
await flush();
|
|
expect(calls).toHaveLength(MAX_CONCURRENT);
|
|
|
|
for (let index = 0; index < accepted.length; index += MAX_CONCURRENT) {
|
|
calls.slice(index, index + MAX_CONCURRENT).forEach((call) => succeed(call));
|
|
await flush();
|
|
}
|
|
await Promise.all(accepted);
|
|
|
|
// A full queue is not remembered: once there is room, the same clip transcodes.
|
|
const retry = resolveProxy(projectDir, sourcePaths.at(-1)!);
|
|
await flush();
|
|
expect(calls).toHaveLength(accepted.length + 1);
|
|
succeed(calls.at(-1)!);
|
|
await expect(retry).resolves.toBeTruthy();
|
|
});
|
|
|
|
it("resolves a whole project's batch past the queue cap by waiting for room, not refusing", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxies } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sources = batchSources(projectDir);
|
|
|
|
let settled = 0;
|
|
const batch = resolveProxies(projectDir, sources, () => settled++);
|
|
await answerUntilIdle(calls, (call) => succeed(call));
|
|
|
|
const results = await batch;
|
|
expect(results.map((result) => result.status)).toEqual(sources.map(() => "fulfilled"));
|
|
expect(settled).toBe(sources.length);
|
|
});
|
|
|
|
it("makes a batch's copy at the box it is given, under that box's own cache name", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxies, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "clip.mov");
|
|
writeFileSync(sourcePath, "source");
|
|
const box = { width: 2048, height: 1448 };
|
|
|
|
const batch = resolveProxies(projectDir, [{ sourcePath, variant: "h264", box }]);
|
|
await answerUntilIdle(calls, (call) => succeed(call));
|
|
|
|
const [result] = await batch;
|
|
expect(result).toEqual({
|
|
status: "fulfilled",
|
|
value: getProxyCachePath(projectDir, sourcePath, "h264", box),
|
|
});
|
|
expect(result.status === "fulfilled" && result.value).not.toBe(
|
|
getProxyCachePath(projectDir, sourcePath, "h264"),
|
|
);
|
|
});
|
|
|
|
it("clears a partial copy left by a stopped process before it starts a batch, and keeps a live one", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxies } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "clip.mov");
|
|
writeFileSync(sourcePath, "source");
|
|
const cacheDir = join(projectDir, ".transcode-cache");
|
|
mkdirSync(cacheDir, { recursive: true });
|
|
const name = (id: string) => `.tmp-${id}-${"a".repeat(64)}.mp4`;
|
|
const dead = join(cacheDir, name("11111111-1111-1111-1111-111111111111"));
|
|
const live = join(cacheDir, name("22222222-2222-2222-2222-222222222222"));
|
|
writeFileSync(dead, "partial");
|
|
writeFileSync(live, "partial");
|
|
const minutesAgo = (m: number) => new Date(Date.now() - m * 60_000);
|
|
utimesSync(dead, minutesAgo(11), minutesAgo(11));
|
|
utimesSync(live, minutesAgo(1), minutesAgo(1));
|
|
|
|
const batch = resolveProxies(projectDir, [{ sourcePath, variant: "h264" }]);
|
|
await answerUntilIdle(calls, (call) => succeed(call));
|
|
await batch;
|
|
|
|
expect(existsSync(dead)).toBe(false);
|
|
expect(existsSync(live)).toBe(true);
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")(
|
|
"still makes a copy in a .transcode-cache that links outside the project, but never sweeps it",
|
|
async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxies } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "clip.mov");
|
|
writeFileSync(sourcePath, "source");
|
|
const outside = mkdtempSync(join(tmpdir(), "hf-proxy-outside-"));
|
|
const stale = join(
|
|
outside,
|
|
`.tmp-11111111-1111-1111-1111-111111111111-${"a".repeat(64)}.mp4`,
|
|
);
|
|
writeFileSync(stale, "someone else's file");
|
|
const longAgo = new Date(Date.now() - 60 * 60_000);
|
|
utimesSync(stale, longAgo, longAgo);
|
|
symlinkSync(outside, join(projectDir, ".transcode-cache"));
|
|
|
|
const batch = resolveProxies(projectDir, [{ sourcePath, variant: "h264" }]);
|
|
await answerUntilIdle(calls, (call) => succeed(call));
|
|
const [result] = await batch;
|
|
|
|
expect(result?.status).toBe("fulfilled");
|
|
expect(existsSync(stale)).toBe(true);
|
|
rmSync(outside, { recursive: true, force: true });
|
|
},
|
|
);
|
|
|
|
it("settles each request of a batch on its own when one of them fails", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxies } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sources = batchSources(projectDir);
|
|
const failing = (call: SpawnCall) => call.args.some((arg) => arg.endsWith("batch-3.mov"));
|
|
|
|
const batch = resolveProxies(projectDir, sources);
|
|
await answerUntilIdle(calls, (call) => (failing(call) ? fail(call) : succeed(call)));
|
|
|
|
const statuses = (await batch).map((result) => result.status);
|
|
expect(statuses.filter((status) => status === "fulfilled")).toHaveLength(sources.length - 1);
|
|
expect(statuses[3]).toBe("rejected");
|
|
});
|
|
|
|
describe("queue order and callers that leave", () => {
|
|
function clipOf(call: SpawnCall): string {
|
|
return basename(call.args[call.args.indexOf("-i") + 1]!, ".mov");
|
|
}
|
|
|
|
function clips(projectDir: string, names: string[]): Record<string, string> {
|
|
return Object.fromEntries(
|
|
names.map((name) => {
|
|
const path = join(projectDir, `${name}.mov`);
|
|
writeFileSync(path, name);
|
|
return [name, path];
|
|
}),
|
|
);
|
|
}
|
|
|
|
async function askThenLeave(ask: (signal: AbortSignal) => Promise<string>): Promise<void> {
|
|
const leaving = new AbortController();
|
|
const left = ask(leaving.signal);
|
|
await flush();
|
|
leaving.abort();
|
|
await expect(left).rejects.toBe(leaving.signal.reason);
|
|
}
|
|
|
|
async function oneSlot(queue = 8, slots = 1) {
|
|
process.env.HYPERFRAMES_PROXY_MAX_CONCURRENCY = String(slots);
|
|
process.env.HYPERFRAMES_PROXY_MAX_QUEUE = String(queue);
|
|
const spy = createSpawnSpy();
|
|
return { ...spy, ...(await loadModule(spy.spawn, FFMPEG_PATH)), projectDir: tmpProject() };
|
|
}
|
|
|
|
it("moves another project's activity mark when its ask is refused, and copies it once there is room", async () => {
|
|
const { calls, resolveProxy, ProxyCapacityError, proxyActivityMark, projectDir } =
|
|
await oneSlot(0);
|
|
const busyProject = tmpProject();
|
|
const running = resolveProxy(busyProject, clips(busyProject, ["running"]).running!);
|
|
const target = clips(projectDir, ["target"]).target!;
|
|
const before = proxyActivityMark(projectDir);
|
|
|
|
await expect(resolveProxy(projectDir, target)).rejects.toBeInstanceOf(ProxyCapacityError);
|
|
expect(proxyActivityMark(projectDir)).not.toBe(before);
|
|
|
|
succeed(calls[0]!);
|
|
await running;
|
|
const retry = resolveProxy(projectDir, target);
|
|
await flush();
|
|
expect(calls.map(clipOf)).toEqual(["running", "target"]);
|
|
succeed(calls[1]!);
|
|
await retry;
|
|
});
|
|
|
|
it("starts a priority copy before queued thumbnails, even when the queue is full", async () => {
|
|
const { calls, resolveProxy, ProxyCapacityError, projectDir } = await oneSlot(1);
|
|
const clip = clips(projectDir, ["running", "thumb", "late", "preview"]);
|
|
|
|
const running = resolveProxy(projectDir, clip.running!);
|
|
const thumb = resolveProxy(projectDir, clip.thumb!);
|
|
await expect(resolveProxy(projectDir, clip.late!)).rejects.toBeInstanceOf(ProxyCapacityError);
|
|
const preview = resolveProxy(projectDir, clip.preview!, "h264", undefined, {
|
|
priority: true,
|
|
});
|
|
await flush();
|
|
|
|
succeed(calls[0]!);
|
|
await running;
|
|
await flush();
|
|
expect(clipOf(calls[1]!)).toBe("preview");
|
|
succeed(calls[1]!);
|
|
await preview;
|
|
await flush();
|
|
expect(clipOf(calls[2]!)).toBe("thumb");
|
|
succeed(calls[2]!);
|
|
await thumb;
|
|
});
|
|
|
|
it("runs a background copy's encode at the lowest priority, until a viewer asks for it", async () => {
|
|
const setPriority = vi.spyOn(os, "setPriority").mockImplementation(() => {});
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["later", "viewed"]);
|
|
|
|
const later = resolveProxy(projectDir, clip.later!, "h264", undefined, { background: true });
|
|
await flush();
|
|
const lowered = setPriority.mock.calls.length;
|
|
succeed(calls[0]!);
|
|
await later;
|
|
const viewed = resolveProxy(projectDir, clip.viewed!, "h264", undefined, { priority: true });
|
|
await flush();
|
|
succeed(calls[1]!);
|
|
await viewed;
|
|
|
|
expect(lowered).toBe(1);
|
|
expect(setPriority).toHaveBeenCalledTimes(1);
|
|
setPriority.mockRestore();
|
|
});
|
|
|
|
it("moves an already queued copy forward when the preview asks for it", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running", "first", "second"]);
|
|
|
|
const asks = [
|
|
resolveProxy(projectDir, clip.running!),
|
|
resolveProxy(projectDir, clip.first!),
|
|
resolveProxy(projectDir, clip.second!),
|
|
resolveProxy(projectDir, clip.second!, "h264", undefined, { priority: true }),
|
|
];
|
|
await flush();
|
|
succeed(calls[0]!);
|
|
await flush(12);
|
|
|
|
expect(clipOf(calls[1]!)).toBe("second");
|
|
succeed(calls[1]!);
|
|
await flush(12);
|
|
succeed(calls[2]!);
|
|
await Promise.all(asks);
|
|
expect(calls).toHaveLength(3);
|
|
});
|
|
|
|
it("drops a queued copy once its only caller leaves, without remembering a failure", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running", "thumb"]);
|
|
const scrolledOff = new AbortController();
|
|
|
|
const running = resolveProxy(projectDir, clip.running!);
|
|
const thumb = resolveProxy(projectDir, clip.thumb!, "h264", undefined, {
|
|
signal: scrolledOff.signal,
|
|
});
|
|
await flush();
|
|
scrolledOff.abort();
|
|
await expect(thumb).rejects.toBe(scrolledOff.signal.reason);
|
|
|
|
succeed(calls[0]!);
|
|
await running;
|
|
await flush(12);
|
|
expect(calls).toHaveLength(1);
|
|
|
|
const again = resolveProxy(projectDir, clip.thumb!);
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
succeed(calls[1]!);
|
|
await expect(again).resolves.toBeTruthy();
|
|
});
|
|
|
|
it.each([
|
|
["another caller with a signal", true],
|
|
["a caller without a signal", false],
|
|
])("keeps a shared queued copy while %s still waits", async (_label, withSignal) => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running", "shared"]);
|
|
|
|
const running = resolveProxy(projectDir, clip.running!);
|
|
const staying = resolveProxy(
|
|
projectDir,
|
|
clip.shared!,
|
|
"h264",
|
|
undefined,
|
|
withSignal ? { signal: new AbortController().signal } : {},
|
|
);
|
|
await askThenLeave((signal) =>
|
|
resolveProxy(projectDir, clip.shared!, "h264", undefined, { signal }),
|
|
);
|
|
|
|
succeed(calls[0]!);
|
|
await running;
|
|
await flush(12);
|
|
expect(clipOf(calls[1]!)).toBe("shared");
|
|
succeed(calls[1]!);
|
|
await expect(staying).resolves.toBeTruthy();
|
|
});
|
|
|
|
it("makes the copy asked for last first, and moves a copy to the front each time it is asked again", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running", "c", "d", "f"]);
|
|
const ask = (name: string) =>
|
|
resolveProxy(projectDir, clip[name]!, "h264", undefined, { priority: true });
|
|
|
|
const running = resolveProxy(projectDir, clip.running!);
|
|
await flush();
|
|
const asks = [ask("c"), ask("d"), ask("f"), ask("c")];
|
|
succeed(calls[0]!);
|
|
await running;
|
|
for (const next of ["c", "f", "d"]) {
|
|
await flush(12);
|
|
expect(clipOf(calls[calls.length - 1]!)).toBe(next);
|
|
succeed(calls[calls.length - 1]!);
|
|
}
|
|
await expect(Promise.all(asks)).resolves.toHaveLength(4);
|
|
});
|
|
|
|
it("makes the copy when the preview asks in the same moment the last thumbnail leaves", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running", "handoff"]);
|
|
const leaving = new AbortController();
|
|
|
|
const running = resolveProxy(projectDir, clip.running!);
|
|
const thumb = resolveProxy(projectDir, clip.handoff!, "h264", undefined, {
|
|
signal: leaving.signal,
|
|
});
|
|
await flush();
|
|
leaving.abort();
|
|
const preview = resolveProxy(projectDir, clip.handoff!, "h264", undefined, {
|
|
priority: true,
|
|
});
|
|
await expect(thumb).rejects.toBe(leaving.signal.reason);
|
|
|
|
succeed(calls[0]!);
|
|
await running;
|
|
await flush(12);
|
|
expect(clipOf(calls[1]!)).toBe("handoff");
|
|
succeed(calls[1]!);
|
|
await expect(preview).resolves.toBeTruthy();
|
|
});
|
|
|
|
it("keeps one copy per clip when a dropped copy settles after its replacement started", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot(8, 2);
|
|
const clip = clips(projectDir, ["first", "second", "handoff"]);
|
|
const leaving = new AbortController();
|
|
|
|
const running = [
|
|
resolveProxy(projectDir, clip.first!),
|
|
resolveProxy(projectDir, clip.second!),
|
|
];
|
|
const thumb = resolveProxy(projectDir, clip.handoff!, "h264", undefined, {
|
|
signal: leaving.signal,
|
|
});
|
|
await flush();
|
|
leaving.abort();
|
|
const preview = resolveProxy(projectDir, clip.handoff!);
|
|
await expect(thumb).rejects.toBe(leaving.signal.reason);
|
|
await flush(12);
|
|
const later = resolveProxy(projectDir, clip.handoff!);
|
|
|
|
succeed(calls[0]!);
|
|
succeed(calls[1]!);
|
|
await Promise.all(running);
|
|
await flush(12);
|
|
expect(calls.map(clipOf).filter((name) => name === "handoff")).toHaveLength(1);
|
|
succeed(calls[2]!);
|
|
await expect(Promise.all([preview, later])).resolves.toHaveLength(2);
|
|
});
|
|
|
|
it("accepts a priority ask in the same moment a normal ask for that clip was refused", async () => {
|
|
const { calls, resolveProxy, ProxyCapacityError, projectDir } = await oneSlot(1);
|
|
const clip = clips(projectDir, ["running", "thumb", "late"]);
|
|
|
|
const running = resolveProxy(projectDir, clip.running!);
|
|
const thumb = resolveProxy(projectDir, clip.thumb!);
|
|
const refused = resolveProxy(projectDir, clip.late!);
|
|
const preview = resolveProxy(projectDir, clip.late!, "h264", undefined, { priority: true });
|
|
await expect(refused).rejects.toBeInstanceOf(ProxyCapacityError);
|
|
|
|
succeed(calls[0]!);
|
|
await running;
|
|
await flush(12);
|
|
expect(clipOf(calls[1]!)).toBe("late");
|
|
succeed(calls[1]!);
|
|
await expect(preview).resolves.toBeTruthy();
|
|
await flush(12);
|
|
succeed(calls[2]!);
|
|
await thumb;
|
|
});
|
|
|
|
it("stops a started copy once its last caller leaves, and starts afresh on the next ask", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running"]);
|
|
|
|
await askThenLeave((signal) =>
|
|
resolveProxy(projectDir, clip.running!, "h264", undefined, { signal }),
|
|
);
|
|
|
|
expect(calls[0]!.options?.signal?.aborted).toBe(true);
|
|
calls[0]!.proc.emit("close", null, "SIGKILL");
|
|
await flush(12);
|
|
const again = resolveProxy(projectDir, clip.running!);
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
succeed(calls[1]!);
|
|
await expect(again).resolves.toBeTruthy();
|
|
});
|
|
|
|
it("keeps a started copy while a caller without a signal still waits", async () => {
|
|
const { calls, resolveProxy, projectDir } = await oneSlot();
|
|
const clip = clips(projectDir, ["running"]);
|
|
const kept = resolveProxy(projectDir, clip.running!);
|
|
|
|
await askThenLeave((signal) =>
|
|
resolveProxy(projectDir, clip.running!, "h264", undefined, { signal }),
|
|
);
|
|
|
|
expect(calls[0]!.options?.signal?.aborted).not.toBe(true);
|
|
succeed(calls[0]!);
|
|
await expect(kept).resolves.toBeTruthy();
|
|
expect(calls).toHaveLength(1);
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")(
|
|
"kills the running ffmpeg when its last caller leaves",
|
|
async () => {
|
|
let child: ChildProcess | undefined;
|
|
const neverFinishes = (_command: string, _args: string[], options?: SpawnOptions) => {
|
|
child = realSpawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], options);
|
|
return child as unknown as FakeProc;
|
|
};
|
|
const { resolveProxy } = await loadModule(neverFinishes, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const clip = clips(projectDir, ["running"]);
|
|
|
|
await askThenLeave((signal) =>
|
|
resolveProxy(projectDir, clip.running!, "h264", undefined, { signal }),
|
|
);
|
|
|
|
const [, exitSignal] = child!.exitCode === null ? await once(child!, "exit") : [];
|
|
expect(exitSignal).toBe("SIGKILL");
|
|
},
|
|
);
|
|
});
|
|
|
|
it("honors bounded concurrency and queue environment overrides", async () => {
|
|
process.env.HYPERFRAMES_PROXY_MAX_CONCURRENCY = "1";
|
|
process.env.HYPERFRAMES_PROXY_MAX_QUEUE = "0";
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxyCapacityError } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const firstPath = join(projectDir, "first.mov");
|
|
const secondPath = join(projectDir, "second.mov");
|
|
writeFileSync(firstPath, "first");
|
|
writeFileSync(secondPath, "second");
|
|
|
|
const first = resolveProxy(projectDir, firstPath);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
await expect(resolveProxy(projectDir, secondPath)).rejects.toBeInstanceOf(ProxyCapacityError);
|
|
|
|
succeed(calls[0]!);
|
|
await expect(first).resolves.toBeTruthy();
|
|
});
|
|
|
|
describe("finding the copy of a source", () => {
|
|
/** Makes the copy of `sourcePath` and returns the path it was made at. */
|
|
async function made(
|
|
env: Awaited<ReturnType<typeof loadModule>>,
|
|
calls: SpawnCall[],
|
|
projectDir: string,
|
|
sourcePath: string,
|
|
): Promise<string> {
|
|
const before = calls.length;
|
|
const result = env.resolveProxy(projectDir, sourcePath);
|
|
await flush(80);
|
|
for (const call of calls.slice(before)) succeed(call);
|
|
return result;
|
|
}
|
|
|
|
it("reuses the copy of a file that was only touched or re-saved with the same bytes", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const env = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const first = await made(env, calls, projectDir, sourcePath);
|
|
|
|
const future = new Date(Date.now() + 60_000);
|
|
utimesSync(sourcePath, future, future);
|
|
const again = await made(env, calls, projectDir, sourcePath);
|
|
|
|
expect(again).toBe(first);
|
|
expect(calls).toHaveLength(1);
|
|
expect(env.getProxyCachePath(projectDir, sourcePath)).toBe(first);
|
|
});
|
|
|
|
it("gives a copied project the copy its original has, and a symlinked clip the same one", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const env = await loadModule(spawn, FFMPEG_PATH);
|
|
const original = tmpProject();
|
|
writeFileSync(join(original, "video.mov"), "source-bytes");
|
|
symlinkSync(join(original, "video.mov"), join(original, "linked.mov"));
|
|
const first = await made(env, calls, original, join(original, "video.mov"));
|
|
const copied = join(tmpProject(), "project");
|
|
cpSync(original, copied, { recursive: true, dereference: true });
|
|
for (const name of readdirSync(copied))
|
|
utimesSync(join(copied, name), new Date(), new Date(Date.now() + 5_000));
|
|
|
|
const viaLink = await made(env, calls, original, join(original, "linked.mov"));
|
|
const inCopy = await made(env, calls, copied, join(copied, "video.mov"));
|
|
|
|
expect(viaLink).toBe(first);
|
|
expect(inCopy.startsWith(realpathSync(copied))).toBe(true);
|
|
expect(calls).toHaveLength(1);
|
|
});
|
|
|
|
it("makes a new copy for a changed file, even one of the same size that differs in a small stretch", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const env = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "big.mov");
|
|
const bytes = Buffer.alloc(1024 * 1024, 1);
|
|
writeFileSync(sourcePath, bytes);
|
|
const pinned = new Date("2026-01-01T00:00:00Z");
|
|
utimesSync(sourcePath, pinned, pinned);
|
|
const first = await made(env, calls, projectDir, sourcePath);
|
|
|
|
bytes[200 * 1024] = 2;
|
|
writeFileSync(sourcePath, bytes);
|
|
utimesSync(sourcePath, new Date(pinned.getTime() + 1000), new Date(pinned.getTime() + 1000));
|
|
const second = await made(env, calls, projectDir, sourcePath);
|
|
|
|
expect(second).not.toBe(first);
|
|
expect(calls).toHaveLength(2);
|
|
});
|
|
|
|
it("makes a new copy when a link is retargeted to other bytes", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const env = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
writeFileSync(join(projectDir, "a.mov"), "source-bytes");
|
|
writeFileSync(join(projectDir, "b.mov"), "SOURCE-BYTES");
|
|
symlinkSync(join(projectDir, "a.mov"), join(projectDir, "linked.mov"));
|
|
const first = await made(env, calls, projectDir, join(projectDir, "linked.mov"));
|
|
|
|
rmSync(join(projectDir, "linked.mov"));
|
|
symlinkSync(join(projectDir, "b.mov"), join(projectDir, "linked.mov"));
|
|
const second = await made(env, calls, projectDir, join(projectDir, "linked.mov"));
|
|
|
|
expect(second).not.toBe(first);
|
|
expect(calls).toHaveLength(2);
|
|
});
|
|
});
|
|
|
|
it("produces a new cache key when size changes but mtime is pinned the same", async () => {
|
|
const { getProxyCachePath } = await loadModule(() => createFakeProc(), FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
const pinned = new Date("2026-01-01T00:00:00Z");
|
|
|
|
writeFileSync(sourcePath, "short");
|
|
utimesSync(sourcePath, pinned, pinned);
|
|
const keyBefore = getProxyCachePath(projectDir, sourcePath);
|
|
|
|
writeFileSync(sourcePath, "a much longer replacement payload");
|
|
utimesSync(sourcePath, pinned, pinned);
|
|
const keyAfter = getProxyCachePath(projectDir, sourcePath);
|
|
|
|
expect(keyAfter).not.toBe(keyBefore);
|
|
});
|
|
|
|
it("surfaces a typed error on ffmpeg failure and leaves no cache file", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath, ProxyTranscodeError } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const cachePath = getProxyCachePath(projectDir, sourcePath);
|
|
|
|
const resultPromise = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
fail(
|
|
calls[0]!,
|
|
1,
|
|
[
|
|
"Input #0, mov, from 'video.mov': unsupported codec",
|
|
"[hevc] Error while decoding stream #0:0: Invalid data found when processing input",
|
|
"Error submitting a packet to the muxer: No space left on device.",
|
|
"Conversion failed!",
|
|
].join("\n"),
|
|
);
|
|
|
|
await expect(resultPromise).rejects.toBeInstanceOf(ProxyTranscodeError);
|
|
await expect(resultPromise).rejects.toMatchObject({
|
|
message: expect.stringContaining(
|
|
"ffmpeg exited with code 1: [hevc] Error while decoding stream #0:0: Invalid data found when processing input; Error submitting a packet to the muxer: No space left on device (source: video,",
|
|
),
|
|
exitCode: 1,
|
|
stderrTail: expect.stringContaining("unsupported codec"),
|
|
});
|
|
|
|
expect(existsSync(cachePath)).toBe(false);
|
|
const cacheDir = join(projectDir, ".transcode-cache");
|
|
const leftover = existsSync(cacheDir) ? readdirSync(cacheDir) : [];
|
|
expect(leftover).toEqual([]);
|
|
});
|
|
|
|
it("says how far the copy being made has got, and makes a failed one again when told to retry", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, proxyCopyProgress, retryProxyCopy } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
20,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const first = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
expect(proxyCopyProgress(projectDir, sourcePath, "h264")).toBeUndefined();
|
|
calls[0]!.proc.stdout.emit("data", Buffer.from("out_time_us=5000000\n"));
|
|
expect(proxyCopyProgress(projectDir, sourcePath, "h264")).toBeCloseTo(0.25);
|
|
fail(calls[0]!, 1, "boom");
|
|
await first;
|
|
expect(proxyCopyProgress(projectDir, sourcePath, "h264")).toBeUndefined();
|
|
|
|
const stillFailed = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
await stillFailed;
|
|
|
|
retryProxyCopy(projectDir, sourcePath, "h264");
|
|
const again = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
succeed(calls[1]!);
|
|
await again;
|
|
});
|
|
|
|
it("names why the output could not open, not only that it could not", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "phone.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
fail(
|
|
calls[0]!,
|
|
234,
|
|
[
|
|
"[out#0/mp4 @ 0x1] Output file does not contain any stream",
|
|
"Error opening output file /project/.transcode-cache/.tmp-1-abc.mp4.",
|
|
"Error opening output files: Invalid argument",
|
|
].join("\n"),
|
|
);
|
|
|
|
expect(String(await result)).toContain(
|
|
"ffmpeg exited with code 234: [out#0/mp4 @ 0x1] Output file does not contain any stream; Error opening output files: Invalid argument",
|
|
);
|
|
});
|
|
|
|
it("ends a failure with what the source is, without its name or folder", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH, false, null, "hevc", undefined, [
|
|
"video:hevc[default]",
|
|
"data:?[]",
|
|
]);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "Phone Clip.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
fail(calls[0]!, 234, "Error opening output files: Invalid argument");
|
|
|
|
const message = String(await result);
|
|
expect(message).toContain(
|
|
"(source: video, hevc, no audio, streams video:hevc[default] data:?[], 0 MB, local)",
|
|
);
|
|
expect(message).not.toContain("Phone Clip");
|
|
expect(message).not.toContain(projectDir);
|
|
});
|
|
|
|
it("keeps a spaced file or folder name out of the failure, and survives a source that vanished", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "My Project", "Screen Recording 2026.mov");
|
|
mkdirSync(dirname(sourcePath));
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath).catch((error: unknown) => error);
|
|
await flush();
|
|
rmSync(sourcePath);
|
|
const input = calls[0]!.args[calls[0]!.args.indexOf("-i") + 1];
|
|
fail(
|
|
calls[0]!,
|
|
234,
|
|
`Error opening input file ${input}.\nError opening input files: Invalid argument`,
|
|
);
|
|
|
|
const message = String(await result);
|
|
expect(message).toContain("Error opening input file <path>");
|
|
expect(message).toContain("missing");
|
|
expect(message).not.toMatch(/My Project|Screen Recording/);
|
|
});
|
|
|
|
it("remembers a failure per cache key: a second call rethrows without respawning ffmpeg", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxyTranscodeError, clearFailedTranscodesForTest } = await loadModule(
|
|
spawn,
|
|
FFMPEG_PATH,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const first = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
fail(calls[0]!, 1, "ffmpeg: unsupported codec");
|
|
await expect(first).rejects.toBeInstanceOf(ProxyTranscodeError);
|
|
|
|
// Same key, remembered failure: rethrown instantly, no second spawn.
|
|
await expect(resolveProxy(projectDir, sourcePath)).rejects.toMatchObject({
|
|
stderrTail: expect.stringContaining("unsupported codec"),
|
|
});
|
|
expect(calls).toHaveLength(1);
|
|
|
|
// The exported clear hook forgets the failure and allows a retry.
|
|
clearFailedTranscodesForTest();
|
|
const retry = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
expect(calls[1]!.options?.windowsHide).toBe(true);
|
|
succeed(calls[1]!);
|
|
await expect(retry).resolves.toBeTruthy();
|
|
});
|
|
|
|
it("expires remembered failures so transient environment errors can recover", async () => {
|
|
const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxyTranscodeError } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const first = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
fail(calls[0]!, 137, "transient OOM");
|
|
await expect(first).rejects.toBeInstanceOf(ProxyTranscodeError);
|
|
|
|
now.mockReturnValue(1_000 + 60_001);
|
|
const retry = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
succeed(calls[1]!);
|
|
await expect(retry).resolves.toBeTruthy();
|
|
});
|
|
|
|
// A real ffprobe answers after a macrotask, so a failure lands after a zero wait gave up.
|
|
async function loadWithSlowProbe(
|
|
spawn: SpawnImpl,
|
|
ffmpegPath: () => string | undefined,
|
|
probe: () => Promise<unknown>,
|
|
): Promise<typeof import("./proxyTranscoder.js")> {
|
|
vi.resetModules();
|
|
vi.doMock("node:child_process", () => {
|
|
const mocked = { spawn };
|
|
return { ...mocked, default: mocked };
|
|
});
|
|
vi.doMock("@hyperframes/parsers/ff-binaries", async (importOriginal) => ({
|
|
...(await importOriginal<typeof import("@hyperframes/parsers/ff-binaries")>()),
|
|
findFfBinary: ffmpegPath,
|
|
}));
|
|
vi.doMock("./mediaMetadata.js", () => ({
|
|
probeMediaMetadata: () =>
|
|
new Promise((resolveProbe) => setTimeout(resolveProbe, 5)).then(probe),
|
|
}));
|
|
return import("./proxyTranscoder.js");
|
|
}
|
|
|
|
const sleep = (ms: number) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
|
|
|
|
it("keeps an environment failure briefly, so an ask that stopped waiting hears it next", async () => {
|
|
const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
|
|
const { spawn, calls } = createSpawnSpy();
|
|
let ffmpegPath: string | undefined;
|
|
const { resolveProxy, waitForProxy, ProxyWaitTimeoutError } = await loadWithSlowProbe(
|
|
spawn,
|
|
() => ffmpegPath,
|
|
async () => ({ kind: "video", color: { isHdr: false } }),
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
await expect(waitForProxy(resolveProxy(projectDir, sourcePath), 0)).rejects.toBeInstanceOf(
|
|
ProxyWaitTimeoutError,
|
|
);
|
|
await sleep(30);
|
|
await expect(waitForProxy(resolveProxy(projectDir, sourcePath), 0)).rejects.toThrow(
|
|
"ffmpeg binary not found",
|
|
);
|
|
|
|
ffmpegPath = FFMPEG_PATH;
|
|
now.mockReturnValue(1_000 + 10_001);
|
|
const retry = resolveProxy(projectDir, sourcePath);
|
|
await sleep(30);
|
|
expect(calls).toHaveLength(1);
|
|
succeed(calls[0]!);
|
|
await expect(retry).resolves.toBeTruthy();
|
|
now.mockRestore();
|
|
});
|
|
|
|
it("remembers a failure that is not a transcode error, so it is not retried on every ask", async () => {
|
|
const { spawn } = createSpawnSpy();
|
|
const probe = vi.fn(async () => {
|
|
throw new Error("EBUSY: file locked");
|
|
});
|
|
const { resolveProxy, waitForProxy, ProxyWaitTimeoutError } = await loadWithSlowProbe(
|
|
spawn,
|
|
() => FFMPEG_PATH,
|
|
probe,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
await expect(waitForProxy(resolveProxy(projectDir, sourcePath), 0)).rejects.toBeInstanceOf(
|
|
ProxyWaitTimeoutError,
|
|
);
|
|
await sleep(30);
|
|
await expect(waitForProxy(resolveProxy(projectDir, sourcePath), 0)).rejects.toThrow("EBUSY");
|
|
expect(probe).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("marks a project's copy as in flight, and moves the mark once it lands", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, proxyActivityMark } = await loadWithSlowProbe(
|
|
spawn,
|
|
() => FFMPEG_PATH,
|
|
async () => ({ kind: "video", color: { isHdr: false } }),
|
|
);
|
|
const projectDir = tmpProject();
|
|
const otherProjectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const before = proxyActivityMark(projectDir);
|
|
|
|
const copy = resolveProxy(projectDir, sourcePath);
|
|
expect(proxyActivityMark(projectDir)).toBeNull();
|
|
expect(proxyActivityMark(otherProjectDir)).toBe(before);
|
|
await vi.waitFor(() => expect(calls).toHaveLength(1));
|
|
succeed(calls[0]!);
|
|
await copy;
|
|
expect(proxyActivityMark(projectDir)).not.toBeNull();
|
|
expect(proxyActivityMark(projectDir)).not.toBe(before);
|
|
expect(proxyActivityMark(join(projectDir, "missing"))).not.toBeNull();
|
|
});
|
|
|
|
it("rejects sources outside the project before probing or spawning", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxySourceOutsideProjectError } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const outsideDir = tmpProject();
|
|
const sourcePath = join(outsideDir, "outside.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
await expect(resolveProxy(projectDir, sourcePath)).rejects.toBeInstanceOf(
|
|
ProxySourceOutsideProjectError,
|
|
);
|
|
expect(calls).toHaveLength(0);
|
|
});
|
|
|
|
it("proxies an external target reached through an in-project symlink", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const outsideDir = tmpProject();
|
|
const outsidePath = join(outsideDir, "outside.mov");
|
|
const sourcePath = join(projectDir, "linked.mov");
|
|
writeFileSync(outsidePath, "source-bytes");
|
|
symlinkSync(outsidePath, sourcePath);
|
|
|
|
const cachePath = getProxyCachePath(projectDir, sourcePath);
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
|
|
expect(calls).toHaveLength(1);
|
|
expect(calls[0]?.args).toContain(realpathSync(outsidePath));
|
|
succeed(calls[0]!);
|
|
await expect(result).resolves.toBe(cachePath);
|
|
expect(cachePath.startsWith(join(realpathSync(projectDir), ".transcode-cache"))).toBe(true);
|
|
});
|
|
|
|
it("retries after the source file changes (its content in the cache key invalidates the remembered failure)", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxyTranscodeError } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const past = new Date(Date.now() - 60_000);
|
|
utimesSync(sourcePath, past, past);
|
|
|
|
const first = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
fail(calls[0]!, 1, "boom");
|
|
await expect(first).rejects.toBeInstanceOf(ProxyTranscodeError);
|
|
|
|
// Re-exported file (new bytes) → new key → a fresh transcode attempt.
|
|
writeFileSync(sourcePath, "re-exported-bytes");
|
|
const retry = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
succeed(calls[1]!);
|
|
await expect(retry).resolves.toBeTruthy();
|
|
});
|
|
|
|
describe("two processes sharing one cache", () => {
|
|
it("lets only one make the copy, and gives both the finished file", async () => {
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const first = createSpawnSpy();
|
|
const second = createSpawnSpy();
|
|
const a = await loadModule(first.spawn, FFMPEG_PATH);
|
|
const b = await loadModule(second.spawn, FFMPEG_PATH);
|
|
|
|
const madeByA = a.resolveProxy(projectDir, sourcePath);
|
|
await flush(50);
|
|
const madeByB = b.resolveProxy(projectDir, sourcePath);
|
|
await new Promise((resolveWait) => setTimeout(resolveWait, 700));
|
|
expect(first.calls).toHaveLength(1);
|
|
expect(second.calls).toHaveLength(0);
|
|
|
|
succeed(first.calls[0]!);
|
|
const paths = await Promise.all([madeByA, madeByB]);
|
|
|
|
expect(paths[1]).toBe(paths[0]);
|
|
expect(second.calls).toHaveLength(0);
|
|
expect(copiesIn(join(projectDir, ".transcode-cache"))).toEqual([basename(paths[0]!)]);
|
|
});
|
|
|
|
it("takes over from a process that died, and clears its lock when done", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, getProxyCachePath } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
const cachePath = getProxyCachePath(projectDir, sourcePath);
|
|
mkdirSync(dirname(cachePath), { recursive: true });
|
|
const lockPath = join(dirname(cachePath), `.lock-${basename(cachePath)}`);
|
|
writeFileSync(lockPath, "99999999");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush(50);
|
|
expect(calls).toHaveLength(1);
|
|
succeed(calls[0]!);
|
|
|
|
await expect(result).resolves.toBe(cachePath);
|
|
expect(existsSync(lockPath)).toBe(false);
|
|
});
|
|
});
|
|
|
|
it("throws a typed error when ffmpeg cannot be resolved, without spawning", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, ProxyTranscodeError } = await loadModule(spawn, undefined);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
await expect(resolveProxy(projectDir, sourcePath)).rejects.toBeInstanceOf(ProxyTranscodeError);
|
|
expect(calls).toHaveLength(0);
|
|
});
|
|
|
|
it("treats an ffmpeg that cannot start as an unusable environment, not a bad source", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
const { resolveProxy, FfmpegUnavailableError } = await loadModule(spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const sourcePath = join(projectDir, "video.mov");
|
|
writeFileSync(sourcePath, "source-bytes");
|
|
|
|
const result = resolveProxy(projectDir, sourcePath);
|
|
await flush();
|
|
calls[0]!.proc.emit("error", new Error("EACCES"));
|
|
|
|
await expect(result).rejects.toBeInstanceOf(FfmpegUnavailableError);
|
|
});
|
|
});
|
|
|
|
describe("resolveStill", () => {
|
|
const canStill = Boolean(realFfmpeg) && Boolean(findFfBinary("ffprobe"));
|
|
|
|
it("refuses a playlist named as a video without running ffmpeg", async () => {
|
|
const { spawn, calls } = createSpawnSpy();
|
|
vi.resetModules();
|
|
vi.doMock("node:child_process", () => ({ spawn, default: { spawn } }));
|
|
vi.doMock("@hyperframes/parsers/ff-binaries", () => ({ findFfBinary: () => FFMPEG_PATH }));
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveStill } = await import("./proxyTranscoder.js");
|
|
const projectDir = tmpProject();
|
|
const clip = join(projectDir, "clip.mp4");
|
|
writeFileSync(clip, "ffconcat version 1.0\n#\u0001\nfile seg.ts\n");
|
|
|
|
await expect(resolveStill(projectDir, clip, 1)).rejects.toThrow("not a media file");
|
|
expect(calls).toHaveLength(0);
|
|
});
|
|
|
|
it.skipIf(!canStill)(
|
|
"cuts one JPEG at the asked time and reuses it for the same tenth of a second",
|
|
async () => {
|
|
vi.resetModules();
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveStill } = await import("./proxyTranscoder.js");
|
|
const projectDir = tmpProject();
|
|
const clip = join(projectDir, "clip.mp4");
|
|
execFileSync(realFfmpeg!, [
|
|
...["-v", "error", "-f", "lavfi", "-i", "testsrc2=s=320x180:r=25:d=3"],
|
|
...["-c:v", "libx264", "-pix_fmt", "yuv420p", clip],
|
|
]);
|
|
|
|
const first = await resolveStill(projectDir, clip, 1.26, { width: 160, height: 90 });
|
|
expect(first.endsWith(".jpg")).toBe(true);
|
|
const bytes = readFileSync(first);
|
|
expect([bytes[0], bytes[1]]).toEqual([0xff, 0xd8]);
|
|
expect(await resolveStill(projectDir, clip, 1.34, { width: 160, height: 90 })).toBe(first);
|
|
expect(await resolveStill(projectDir, clip, 2.5, { width: 160, height: 90 })).not.toBe(first);
|
|
},
|
|
60_000,
|
|
);
|
|
|
|
it.skipIf(!canStill)(
|
|
"sweeps the cache when it makes a still, so stills alone cannot grow it without bound",
|
|
async () => {
|
|
vi.resetModules();
|
|
vi.doUnmock("./mediaMetadata.js");
|
|
const { resolveStill, CACHE_DIR_NAME } = await import("./proxyTranscoder.js");
|
|
const projectDir = tmpProject();
|
|
const clip = join(projectDir, "clip.mp4");
|
|
execFileSync(realFfmpeg!, [
|
|
...["-v", "error", "-f", "lavfi", "-i", "testsrc2=s=320x180:r=25:d=2"],
|
|
...["-c:v", "libx264", "-pix_fmt", "yuv420p", clip],
|
|
]);
|
|
const cacheDir = join(projectDir, CACHE_DIR_NAME);
|
|
mkdirSync(cacheDir, { recursive: true });
|
|
const idle = join(cacheDir, `${"a".repeat(64)}.jpg`);
|
|
writeFileSync(idle, "old still");
|
|
const longAgo = new Date(Date.now() - 31 * 24 * 60 * 60 * 1000);
|
|
utimesSync(idle, longAgo, longAgo);
|
|
|
|
const made = await resolveStill(projectDir, clip, 1);
|
|
|
|
expect(existsSync(made)).toBe(true);
|
|
expect(existsSync(idle)).toBe(false);
|
|
},
|
|
60_000,
|
|
);
|
|
|
|
async function stillSetup() {
|
|
const spy = createSpawnSpy();
|
|
const { resolveStill } = await loadModule(spy.spawn, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const clip = join(projectDir, "clip.mp4");
|
|
writeFileSync(clip, "clip");
|
|
const ask = (signal?: AbortSignal) =>
|
|
resolveStill(projectDir, clip, 1, undefined, undefined, signal);
|
|
return { calls: spy.calls, ask };
|
|
}
|
|
|
|
it("ends a still's ffmpeg once the last request waiting on it leaves, and starts afresh after", async () => {
|
|
const { calls, ask } = await stillSetup();
|
|
const first = new AbortController();
|
|
const second = new AbortController();
|
|
const firstWait = ask(first.signal);
|
|
const secondWait = ask(second.signal);
|
|
await flush();
|
|
expect(calls).toHaveLength(1);
|
|
|
|
first.abort();
|
|
await expect(firstWait).rejects.toBe(first.signal.reason);
|
|
expect(calls[0]!.options?.signal?.aborted).toBe(false);
|
|
second.abort();
|
|
await expect(secondWait).rejects.toBe(second.signal.reason);
|
|
expect(calls[0]!.options?.signal?.aborted).toBe(true);
|
|
|
|
calls[0]!.proc.emit("close", null, "SIGKILL");
|
|
await flush();
|
|
const again = ask();
|
|
await flush();
|
|
expect(calls).toHaveLength(2);
|
|
succeed(calls[1]!);
|
|
await expect(again).resolves.toMatch(/\.jpg$/);
|
|
});
|
|
|
|
it("keeps a still's ffmpeg running while a request without a signal waits on it", async () => {
|
|
const { calls, ask } = await stillSetup();
|
|
const kept = ask();
|
|
const leaving = new AbortController();
|
|
const left = ask(leaving.signal);
|
|
await flush();
|
|
leaving.abort();
|
|
await expect(left).rejects.toBe(leaving.signal.reason);
|
|
|
|
expect(calls[0]!.options?.signal?.aborted).toBe(false);
|
|
succeed(calls[0]!);
|
|
await expect(kept).resolves.toMatch(/\.jpg$/);
|
|
expect(calls).toHaveLength(1);
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")(
|
|
"kills a still's running ffmpeg when its only request leaves",
|
|
async () => {
|
|
let child: ChildProcess | undefined;
|
|
const neverFinishes = (_command: string, _args: string[], options?: SpawnOptions) => {
|
|
child = realSpawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], options);
|
|
return child as unknown as FakeProc;
|
|
};
|
|
const { resolveStill } = await loadModule(neverFinishes, FFMPEG_PATH);
|
|
const projectDir = tmpProject();
|
|
const clip = join(projectDir, "clip.mp4");
|
|
writeFileSync(clip, "clip");
|
|
const leaving = new AbortController();
|
|
const left = resolveStill(projectDir, clip, 1, undefined, undefined, leaving.signal);
|
|
await flush();
|
|
leaving.abort();
|
|
await expect(left).rejects.toBe(leaving.signal.reason);
|
|
|
|
const [, exitSignal] = child!.exitCode === null ? await once(child!, "exit") : [];
|
|
expect(exitSignal).toBe("SIGKILL");
|
|
},
|
|
);
|
|
|
|
it("starts no ffmpeg for a still past the end of the source", async () => {
|
|
const spy = createSpawnSpy();
|
|
const { resolveStill, StillPastEndError } = await loadModule(
|
|
spy.spawn,
|
|
FFMPEG_PATH,
|
|
false,
|
|
null,
|
|
undefined,
|
|
2,
|
|
);
|
|
const projectDir = tmpProject();
|
|
const clip = join(projectDir, "clip.mp4");
|
|
writeFileSync(clip, "clip");
|
|
|
|
await expect(resolveStill(projectDir, clip, 2.5)).rejects.toBeInstanceOf(StillPastEndError);
|
|
expect(spy.calls).toHaveLength(0);
|
|
});
|
|
|
|
it("starts no ffmpeg for a request that already left", async () => {
|
|
const { calls, ask } = await stillSetup();
|
|
const gone = new AbortController();
|
|
gone.abort();
|
|
await expect(ask(gone.signal)).rejects.toBe(gone.signal.reason);
|
|
await flush();
|
|
expect(calls).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("sourceFolderKind", () => {
|
|
it.each([
|
|
["/Users/a/Library/Mobile Documents/com~apple~CloudDocs/clip.mov", "icloud"],
|
|
["/Users/a/Library/CloudStorage/Dropbox/p/clip.mov", "cloud-storage"],
|
|
["/Users/a/Dropbox (Team)/p/clip.mov", "cloud-storage"],
|
|
["C:\\Users\\a\\OneDrive - Co\\p\\clip.mov", "cloud-storage"],
|
|
["/Volumes/Phone Backup/clip.mov", "external-volume"],
|
|
["/Users/a/Movies/clip.mov", "local"],
|
|
["/Users/a/Dropboxes/clip.mov", "local"],
|
|
])("tells %s apart as %s", async (path, kind) => {
|
|
const { spawn } = createSpawnSpy();
|
|
const { sourceFolderKind } = await loadModule(spawn, FFMPEG_PATH);
|
|
expect(sourceFolderKind(path)).toBe(kind);
|
|
});
|
|
});
|