@simon_he/vue-tui 1.0.2 → 1.1.0

package/dist/experimental/video/node.js

@@ -0,0 +1,610 @@
+//#region src/cli/video/png-frame-parser.ts
+const PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function readUint32(bytes, offset) {
+	return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3] >>> 0;
+}
+function hasPngSignature(bytes, offset) {
+	for (let index = 0; index < PNG_SIGNATURE.length; index++) if (bytes[offset + index] !== PNG_SIGNATURE[index]) return false;
+	return true;
+}
+function isChunkType(bytes, offset, type) {
+	return bytes[offset] === type.charCodeAt(0) && bytes[offset + 1] === type.charCodeAt(1) && bytes[offset + 2] === type.charCodeAt(2) && bytes[offset + 3] === type.charCodeAt(3);
+}
+function validatePngHeader(bytes, offset, maxDimension) {
+	if (readUint32(bytes, offset + 8) !== 13 || !isChunkType(bytes, offset + 12, "IHDR")) throw new Error("FFmpeg emitted a PNG without a valid IHDR chunk");
+	const width = readUint32(bytes, offset + 16);
+	const height = readUint32(bytes, offset + 20);
+	if (width <= 0 || height <= 0 || width > maxDimension || height > maxDimension) throw new Error(`FFmpeg emitted an unsupported PNG size: ${width}x${height}`);
+}
+/** @internal */
+async function* parsePngFrames(chunks, options) {
+	let pending = new Uint8Array(Math.min(64 * 1024, options.maxFrameBytes));
+	let length = 0;
+	let frameStart = 0;
+	let cursor = 0;
+	let headerValidated = false;
+	for await (const chunk of chunks) {
+		if (frameStart > 0) {
+			pending.copyWithin(0, frameStart, length);
+			length -= frameStart;
+			cursor -= frameStart;
+			frameStart = 0;
+		}
+		const required = length + chunk.length;
+		if (required > pending.length) {
+			let capacity = Math.max(1, pending.length);
+			while (capacity < required && capacity < options.maxFrameBytes) capacity = Math.min(options.maxFrameBytes, capacity * 2);
+			const grown = new Uint8Array(Math.max(required, capacity));
+			grown.set(pending.subarray(0, length));
+			pending = grown;
+		}
+		pending.set(chunk, length);
+		length = required;
+		while (length - frameStart >= PNG_SIGNATURE.length) {
+			if (cursor === frameStart) {
+				if (!hasPngSignature(pending, frameStart)) throw new Error("FFmpeg emitted invalid PNG data");
+				cursor = frameStart + PNG_SIGNATURE.length;
+			}
+			if (!headerValidated) {
+				if (length - frameStart < 33) break;
+				validatePngHeader(pending, frameStart, options.maxDimension);
+				headerValidated = true;
+			}
+			if (length - cursor < 12) break;
+			const chunkBytes = readUint32(pending, cursor);
+			const chunkEnd = cursor + 12 + chunkBytes;
+			if (chunkEnd - frameStart > options.maxFrameBytes) throw new Error(`FFmpeg PNG frame exceeded ${options.maxFrameBytes} bytes`);
+			if (chunkEnd > length) break;
+			if (isChunkType(pending, cursor + 4, "IEND")) {
+				if (chunkBytes !== 0) throw new Error("FFmpeg emitted an invalid PNG IEND chunk");
+				yield new Uint8Array(pending.subarray(frameStart, chunkEnd));
+				frameStart = chunkEnd;
+				cursor = frameStart;
+				headerValidated = false;
+				if (frameStart === length) {
+					length = 0;
+					frameStart = 0;
+					cursor = 0;
+				}
+				continue;
+			}
+			cursor = chunkEnd;
+		}
+		if (length - frameStart > options.maxFrameBytes) throw new Error(`FFmpeg PNG frame exceeded ${options.maxFrameBytes} bytes`);
+	}
+	if (length !== frameStart) throw new Error("FFmpeg PNG stream ended with a truncated frame");
+}
+
+//#endregion
+//#region src/cli/video/raw-frame-parser.ts
+/** @internal */
+async function* parseRawFrames(chunks, frameBytes) {
+	if (!Number.isSafeInteger(frameBytes) || frameBytes <= 0) throw new Error("FFmpeg raw video frame size must be a positive integer");
+	let frame = new Uint8Array(frameBytes);
+	let frameOffset = 0;
+	for await (const chunk of chunks) {
+		let chunkOffset = 0;
+		while (chunkOffset < chunk.length) {
+			const copyBytes = Math.min(frameBytes - frameOffset, chunk.length - chunkOffset);
+			frame.set(chunk.subarray(chunkOffset, chunkOffset + copyBytes), frameOffset);
+			frameOffset += copyBytes;
+			chunkOffset += copyBytes;
+			if (frameOffset === frameBytes) {
+				yield frame;
+				frame = new Uint8Array(frameBytes);
+				frameOffset = 0;
+			}
+		}
+	}
+	if (frameOffset !== 0) throw new Error("FFmpeg raw video stream ended with a truncated frame");
+}
+
+//#endregion
+//#region src/cli/video/ffmpeg-frame-source.ts
+const DEFAULT_MAX_FRAME_BYTES = 8 * 1024 * 1024;
+const MAX_PNG_DIMENSION = 4096;
+const MAX_STDERR_CHARS$1 = 16384;
+const KILL_TIMEOUT_MS$1 = 1e3;
+const MIN_FPS = .001;
+function positiveInt$1(value, fallback, max) {
+	const parsed = Math.floor(Number(value));
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return Math.min(max, parsed);
+}
+function positiveNumber(value, fallback, max) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return Math.max(MIN_FPS, Math.min(max, parsed));
+}
+function ffmpegNumber(value) {
+	return Number(value.toFixed(3)).toString();
+}
+function ffmpegHttpHeaders(headers) {
+	if (!headers) return "";
+	const lines = [];
+	for (const [name, value] of Object.entries(headers)) {
+		const hasControlCharacter = [...value].some((character) => {
+			const code = character.charCodeAt(0);
+			return code <= 31 || code === 127;
+		});
+		if (!/^[!#$%&'*+.^_`|~\w-]+$/u.test(name) || hasControlCharacter) throw new Error("Invalid FFmpeg HTTP header");
+		lines.push(`${name}: ${value}`);
+	}
+	return lines.length ? `${lines.join("\r\n")}\r\n` : "";
+}
+function classifyInput(src, live) {
+	var _exec;
+	if (!src.trim()) throw new Error("TVideo src must not be empty");
+	if (/^[a-zA-Z]:[\\/]/u.test(src)) return {
+		protocolWhitelist: "file",
+		readAtNativeRate: !live
+	};
+	const scheme = (_exec = /^([a-zA-Z][a-zA-Z\d+.-]*):/u.exec(src)) === null || _exec === void 0 || (_exec = _exec[1]) === null || _exec === void 0 ? void 0 : _exec.toLowerCase();
+	if (!scheme || scheme === "file") return {
+		protocolWhitelist: "file",
+		readAtNativeRate: !live
+	};
+	if (scheme === "http" || scheme === "https") return {
+		protocolWhitelist: "http,https,httpproxy,tcp,tls",
+		readAtNativeRate: !live
+	};
+	throw new Error(`Unsupported TVideo source protocol: ${scheme}`);
+}
+function pngDimensions(png) {
+	return {
+		width: png[16] * 16777216 + (png[17] << 16) + (png[18] << 8) + png[19] >>> 0,
+		height: png[20] * 16777216 + (png[21] << 16) + (png[22] << 8) + png[23] >>> 0
+	};
+}
+function sanitizeProcessError$1(value) {
+	let out = "";
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code >= 127 && code <= 159) continue;
+		out += character;
+	}
+	return out.trim();
+}
+function abortError$1() {
+	const error = new Error("FFmpeg video decoding aborted");
+	error.name = "AbortError";
+	return error;
+}
+/** @internal */
+function buildFfmpegVideoArgs(context, options = {}) {
+	const live = options.live === true;
+	const realtime = options.realtime !== false;
+	const input = classifyInput(context.src, live);
+	const fps = positiveNumber(context.maxFps, 12, 60);
+	const playbackRate = positiveNumber(context.playbackRate, 1, 3);
+	const width = positiveInt$1(context.pixelWidth, 320, MAX_PNG_DIMENSION);
+	const height = positiveInt$1(context.pixelHeight, 180, MAX_PNG_DIMENSION);
+	const preferredFormat = context.preferredFormat ?? "png";
+	const startAtMs = Math.max(0, Number(context.startAtMs) || 0);
+	const httpHeaders = input.protocolWhitelist === "file" ? "" : ffmpegHttpHeaders(options.httpHeaders);
+	const filters = [
+		playbackRate === 1 ? "setpts=PTS-STARTPTS" : `setpts=(PTS-STARTPTS)/${ffmpegNumber(playbackRate)}`,
+		`fps=${ffmpegNumber(fps)}`,
+		...realtime ? ["realtime"] : [],
+		`scale=${width}:${height}:force_original_aspect_ratio=decrease:flags=fast_bilinear`,
+		`pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2`
+	];
+	return [
+		"-nostdin",
+		"-hide_banner",
+		"-loglevel",
+		"error",
+		...context.loop || options.loop ? ["-stream_loop", "-1"] : [],
+		...startAtMs > 0 && !live ? ["-ss", ffmpegNumber(startAtMs / 1e3)] : [],
+		...realtime && input.readAtNativeRate ? ["-readrate", ffmpegNumber(playbackRate)] : [],
+		"-protocol_whitelist",
+		input.protocolWhitelist,
+		...httpHeaders ? ["-headers", httpHeaders] : [],
+		"-i",
+		context.src,
+		"-map",
+		"0:V:0",
+		"-an",
+		"-sn",
+		"-dn",
+		"-vf",
+		filters.join(","),
+		"-fps_mode",
+		"passthrough",
+		"-threads",
+		"1",
+		...preferredFormat === "gray8" ? [
+			"-f",
+			"rawvideo",
+			"-c:v",
+			"rawvideo",
+			"-pix_fmt",
+			"gray"
+		] : [
+			"-f",
+			"image2pipe",
+			"-c:v",
+			"png",
+			"-pix_fmt",
+			"rgb24",
+			"-compression_level",
+			"1"
+		],
+		"pipe:1"
+	];
+}
+function createFfmpegVideoFrameSource(options = {}) {
+	return async function* ffmpegVideoFrames(context) {
+		var _options$ffmpegPath;
+		if (context.signal.aborted) throw abortError$1();
+		const fps = positiveNumber(context.maxFps, 12, 60);
+		const playbackRate = positiveNumber(context.playbackRate, 1, 3);
+		const startAtMs = Math.max(0, Number(context.startAtMs) || 0);
+		const width = positiveInt$1(context.pixelWidth, 320, MAX_PNG_DIMENSION);
+		const height = positiveInt$1(context.pixelHeight, 180, MAX_PNG_DIMENSION);
+		const preferredFormat = context.preferredFormat ?? "png";
+		const maxFrameBytes = positiveInt$1(options.maxFrameBytes, DEFAULT_MAX_FRAME_BYTES, DEFAULT_MAX_FRAME_BYTES);
+		const rawFrameBytes = width * height;
+		if (preferredFormat === "gray8" && rawFrameBytes > maxFrameBytes) throw new Error(`FFmpeg raw video frame exceeded ${maxFrameBytes} bytes`);
+		const { spawn } = await import("node:child_process");
+		if (context.signal.aborted) throw abortError$1();
+		const executable = ((_options$ffmpegPath = options.ffmpegPath) === null || _options$ffmpegPath === void 0 ? void 0 : _options$ffmpegPath.trim()) || "ffmpeg";
+		const args = buildFfmpegVideoArgs(context, options);
+		const child = spawn(executable, args, {
+			shell: false,
+			windowsHide: true,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdout = child.stdout;
+		const stderr = child.stderr;
+		const decoder = new TextDecoder();
+		let stderrTail = "";
+		let spawnError;
+		let closed = false;
+		let aborted = false;
+		let killTimer = null;
+		stderr.on("data", (chunk) => {
+			stderrTail = `${stderrTail}${decoder.decode(chunk, { stream: true })}`.slice(-MAX_STDERR_CHARS$1);
+		});
+		const closePromise = new Promise((resolve) => {
+			child.once("error", (error) => {
+				spawnError = error;
+			});
+			child.once("close", (code, signal) => {
+				closed = true;
+				if (killTimer != null) clearTimeout(killTimer);
+				killTimer = null;
+				stderrTail = `${stderrTail}${decoder.decode()}`.slice(-MAX_STDERR_CHARS$1);
+				resolve({
+					code,
+					signal
+				});
+			});
+		});
+		const terminate = () => {
+			var _killTimer$unref;
+			if (closed) return;
+			child.kill("SIGTERM");
+			if (killTimer != null) return;
+			killTimer = setTimeout(() => {
+				if (!closed) child.kill("SIGKILL");
+			}, KILL_TIMEOUT_MS$1);
+			(_killTimer$unref = killTimer.unref) === null || _killTimer$unref === void 0 || _killTimer$unref.call(killTimer);
+		};
+		const onAbort = () => {
+			aborted = true;
+			terminate();
+		};
+		context.signal.addEventListener("abort", onAbort, { once: true });
+		if (context.signal.aborted) onAbort();
+		let frameIndex = 0;
+		try {
+			if (preferredFormat === "gray8") for await (const pixels of parseRawFrames(stdout, rawFrameBytes)) {
+				if (aborted || context.signal.aborted) throw abortError$1();
+				const timestampMs = startAtMs + frameIndex * 1e3 * playbackRate / fps;
+				frameIndex++;
+				yield {
+					format: "gray8",
+					pixels,
+					timestampMs,
+					pixelWidth: width,
+					pixelHeight: height
+				};
+			}
+			else for await (const png of parsePngFrames(stdout, {
+				maxFrameBytes,
+				maxDimension: MAX_PNG_DIMENSION
+			})) {
+				if (aborted || context.signal.aborted) throw abortError$1();
+				const timestampMs = startAtMs + frameIndex * 1e3 * playbackRate / fps;
+				frameIndex++;
+				const dimensions = pngDimensions(png);
+				yield {
+					png,
+					timestampMs,
+					pixelWidth: dimensions.width,
+					pixelHeight: dimensions.height
+				};
+			}
+			const exit = await closePromise;
+			if (aborted || context.signal.aborted) throw abortError$1();
+			if (spawnError) throw spawnError;
+			if (exit.code !== 0) {
+				const details = sanitizeProcessError$1(stderrTail);
+				throw new Error(details ? `FFmpeg video decoding failed (${exit.code ?? exit.signal}): ${details}` : `FFmpeg video decoding failed (${exit.code ?? exit.signal})`);
+			}
+		} catch (error) {
+			if (!closed) terminate();
+			await closePromise;
+			if (aborted || context.signal.aborted) throw abortError$1();
+			if (spawnError) throw spawnError;
+			throw error;
+		} finally {
+			context.signal.removeEventListener("abort", onAbort);
+			if (!closed) terminate();
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/video/yt-dlp-frame-source.ts
+const DEFAULT_MAX_SOURCE_HEIGHT = 720;
+const MAX_SOURCE_HEIGHT = 4320;
+const MAX_METADATA_BYTES = 128 * 1024;
+const MAX_STDERR_CHARS = 16384;
+const KILL_TIMEOUT_MS = 1e3;
+const RESOLVED_INPUT_TTL_MS = 5 * 60 * 1e3;
+const METADATA_TEMPLATE = "%(.{url,http_headers,protocol,width,height,fps,vcodec,duration})j";
+const COMMON_SOURCE_HEIGHTS = [
+	144,
+	240,
+	360,
+	480,
+	720,
+	1080,
+	1440,
+	2160,
+	4320
+];
+function positiveInt(value, fallback, max) {
+	const parsed = Math.floor(Number(value));
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return Math.min(max, parsed);
+}
+function resolveSourceHeight(options, context) {
+	const maxSourceHeight = positiveInt(options.maxSourceHeight, DEFAULT_MAX_SOURCE_HEIGHT, MAX_SOURCE_HEIGHT);
+	if (!context) return maxSourceHeight;
+	const minimum = context.preferredFormat === "gray8" ? 144 : 360;
+	const requested = Math.max(minimum, positiveInt(context.pixelHeight, minimum, MAX_SOURCE_HEIGHT));
+	const rounded = COMMON_SOURCE_HEIGHTS.find((height) => height >= requested) ?? MAX_SOURCE_HEIGHT;
+	return Math.min(maxSourceHeight, rounded);
+}
+function resolveSourceFps(context) {
+	const requested = Number(context === null || context === void 0 ? void 0 : context.maxFps);
+	return Math.max(30, Number.isFinite(requested) && requested > 0 ? Math.ceil(requested) : 30);
+}
+function abortError() {
+	const error = new Error("yt-dlp video URL resolution aborted");
+	error.name = "AbortError";
+	return error;
+}
+function sanitizeProcessError(value) {
+	let out = "";
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code >= 127 && code <= 159) continue;
+		out += character;
+	}
+	return out.trim();
+}
+function assertHttpUrl(value, label) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new Error(`${label} must be an HTTP(S) URL`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`${label} must be an HTTP(S) URL`);
+	return url.href;
+}
+/** @internal */
+function buildYtDlpVideoArgs(src, options = {}, context) {
+	var _options$format;
+	const source = assertHttpUrl(src, "yt-dlp source");
+	const sourceHeight = resolveSourceHeight(options, context);
+	const sourceFps = resolveSourceFps(context);
+	const format = ((_options$format = options.format) === null || _options$format === void 0 ? void 0 : _options$format.trim()) || [
+		`bestvideo[height<=${sourceHeight}][fps<=${sourceFps}][protocol^=http][vcodec^=avc1]`,
+		`bestvideo[height<=${sourceHeight}][fps<=${sourceFps}][protocol^=http]`,
+		`bestvideo[height<=${sourceHeight}][protocol^=http][vcodec^=avc1]`,
+		`bestvideo[height<=${sourceHeight}][protocol^=http]`,
+		`best[height<=${sourceHeight}][fps<=${sourceFps}][protocol^=http]`,
+		`best[height<=${sourceHeight}][protocol^=http]`
+	].join("/");
+	return [
+		"--no-config",
+		"--no-playlist",
+		"--no-warnings",
+		"--simulate",
+		"--print",
+		METADATA_TEMPLATE,
+		"--format",
+		format,
+		"--",
+		source
+	];
+}
+async function resolveYtDlpVideoInput(src, signal, options, context) {
+	var _options$ytDlpPath;
+	if (signal.aborted) throw abortError();
+	const { spawn } = await import("node:child_process");
+	if (signal.aborted) throw abortError();
+	const executable = ((_options$ytDlpPath = options.ytDlpPath) === null || _options$ytDlpPath === void 0 ? void 0 : _options$ytDlpPath.trim()) || "yt-dlp";
+	const child = spawn(executable, buildYtDlpVideoArgs(src, options, context), {
+		shell: false,
+		windowsHide: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const decoder = new TextDecoder();
+	const stderrDecoder = new TextDecoder();
+	let stdout = "";
+	let stdoutBytes = 0;
+	let stderrTail = "";
+	let spawnError;
+	let metadataTooLarge = false;
+	let closed = false;
+	let aborted = false;
+	let killTimer = null;
+	const terminate = () => {
+		var _killTimer$unref;
+		if (closed) return;
+		child.kill("SIGTERM");
+		if (killTimer != null) return;
+		killTimer = setTimeout(() => {
+			if (!closed) child.kill("SIGKILL");
+		}, KILL_TIMEOUT_MS);
+		(_killTimer$unref = killTimer.unref) === null || _killTimer$unref === void 0 || _killTimer$unref.call(killTimer);
+	};
+	child.stdout.on("data", (chunk) => {
+		stdoutBytes += chunk.byteLength;
+		if (stdoutBytes > MAX_METADATA_BYTES) {
+			metadataTooLarge = true;
+			terminate();
+			return;
+		}
+		stdout += decoder.decode(chunk, { stream: true });
+	});
+	child.stderr.on("data", (chunk) => {
+		stderrTail = `${stderrTail}${stderrDecoder.decode(chunk, { stream: true })}`.slice(-MAX_STDERR_CHARS);
+	});
+	const closePromise = new Promise((resolve) => {
+		child.once("error", (error) => {
+			spawnError = error;
+		});
+		child.once("close", (code, closeSignal) => {
+			closed = true;
+			if (killTimer != null) clearTimeout(killTimer);
+			killTimer = null;
+			stdout += decoder.decode();
+			stderrTail = `${stderrTail}${stderrDecoder.decode()}`.slice(-MAX_STDERR_CHARS);
+			resolve({
+				code,
+				signal: closeSignal
+			});
+		});
+	});
+	const onAbort = () => {
+		aborted = true;
+		terminate();
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	if (signal.aborted) onAbort();
+	try {
+		const exit = await closePromise;
+		if (aborted || signal.aborted) throw abortError();
+		if (metadataTooLarge) throw new Error("yt-dlp video metadata exceeded 131072 bytes");
+		if (spawnError) {
+			const details = spawnError instanceof Error ? spawnError.message : String(spawnError);
+			throw new Error(`yt-dlp video URL resolution failed: ${details}`);
+		}
+		if (exit.code !== 0) {
+			const details = sanitizeProcessError(stderrTail);
+			throw new Error(details ? `yt-dlp video URL resolution failed (${exit.code ?? exit.signal}): ${details}` : `yt-dlp video URL resolution failed (${exit.code ?? exit.signal})`);
+		}
+		const lines = stdout.trim().split(/\r?\n/u).filter(Boolean);
+		if (lines.length !== 1) throw new Error("yt-dlp returned invalid video metadata");
+		let metadata;
+		try {
+			metadata = JSON.parse(lines[0]);
+		} catch {
+			throw new Error("yt-dlp returned invalid video metadata");
+		}
+		if (!metadata || typeof metadata !== "object") throw new Error("yt-dlp returned invalid video metadata");
+		const raw = metadata;
+		if (typeof raw.url !== "string") throw new Error("yt-dlp returned invalid video metadata");
+		const url = assertHttpUrl(raw.url, "yt-dlp resolved video URL");
+		const httpHeaders = {};
+		if (raw.http_headers != null) {
+			if (typeof raw.http_headers !== "object" || Array.isArray(raw.http_headers)) throw new Error("yt-dlp returned invalid video metadata");
+			for (const [name, value] of Object.entries(raw.http_headers)) {
+				if (typeof value !== "string") throw new Error("yt-dlp returned invalid video metadata");
+				httpHeaders[name] = value;
+			}
+		}
+		let durationMs;
+		if (raw.duration != null) {
+			if (typeof raw.duration !== "number" || !Number.isFinite(raw.duration) || raw.duration < 0) throw new Error("yt-dlp returned invalid video metadata");
+			durationMs = Math.round(raw.duration * 1e3);
+		}
+		return {
+			url,
+			httpHeaders,
+			durationMs
+		};
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		if (!closed) terminate();
+	}
+}
+function createYtDlpVideoFrameSource(options = {}) {
+	const resolvedInputs = new Map();
+	return async function* ytDlpVideoFrames(context) {
+		if (context.signal.aborted) throw abortError();
+		const cacheKey = JSON.stringify(buildYtDlpVideoArgs(context.src, options, context));
+		const cached = resolvedInputs.get(cacheKey);
+		let input;
+		if (cached && cached.expiresAtMs > Date.now()) input = cached.input;
+		else {
+			if (cached) resolvedInputs.delete(cacheKey);
+			input = await resolveYtDlpVideoInput(context.src, context.signal, options, context);
+			resolvedInputs.set(cacheKey, {
+				input,
+				expiresAtMs: Date.now() + RESOLVED_INPUT_TTL_MS
+			});
+		}
+		const ffmpegSource = createFfmpegVideoFrameSource({
+			ffmpegPath: options.ffmpegPath,
+			live: options.live,
+			realtime: options.realtime,
+			maxFrameBytes: options.maxFrameBytes,
+			httpHeaders: input.httpHeaders
+		});
+		const frames = await ffmpegSource({
+			...context,
+			src: input.url
+		});
+		try {
+			if (input.durationMs == null) {
+				yield* frames;
+				return;
+			}
+			for await (const frame of frames) yield {
+				...frame,
+				durationMs: input.durationMs
+			};
+		} catch (error) {
+			if (!(error instanceof Error && error.name === "AbortError")) resolvedInputs.delete(cacheKey);
+			throw error;
+		}
+	};
+}
+
+//#endregion
+export { createFfmpegVideoFrameSource, createYtDlpVideoFrameSource };