Add resilient container repair and processing

Author: richiemcilroy

apps/media-server/bun.lock

@@ -216,12 +216,126 @@ export async function downloadVideoToTemp(
 	}
 }
 
+const REPAIR_TIMEOUT_MS = 5 * 60 * 1000;
+
+export async function repairContainer(
+	inputPath: string,
+	abortSignal?: AbortSignal,
+): Promise<TempFileHandle> {
+	const repairedFile = await createTempFile(".mkv");
+
+	const ffmpegArgs = [
+		"ffmpeg",
+		"-threads",
+		"2",
+		"-err_detect",
+		"ignore_err",
+		"-fflags",
+		"+genpts+igndts",
+		"-i",
+		inputPath,
+		"-c",
+		"copy",
+		"-y",
+		repairedFile.path,
+	];
+
+	console.log(`[repairContainer] Running: ${ffmpegArgs.join(" ")}`);
+
+	const proc = spawn({
+		cmd: ffmpegArgs,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	let abortCleanup: (() => void) | undefined;
+	if (abortSignal) {
+		abortCleanup = () => {
+			killProcess(proc);
+		};
+		abortSignal.addEventListener("abort", abortCleanup, { once: true });
+	}
+
+	try {
+		await withTimeout(
+			(async () => {
+				drainStream(proc.stdout as ReadableStream<Uint8Array>);
+
+				const stderrText = await readStreamWithLimit(
+					proc.stderr as ReadableStream<Uint8Array>,
+					MAX_STDERR_BYTES,
+				);
+
+				const exitCode = await proc.exited;
+
+				if (exitCode !== 0) {
+					console.error(`[repairContainer] FFmpeg stderr:\n${stderrText}`);
+					throw new Error(`Container repair failed with exit code ${exitCode}`);
+				}
+
+				const outputFile = file(repairedFile.path);
+				if (outputFile.size === 0) {
+					throw new Error("Container repair produced empty file");
+				}
+
+				console.log(
+					`[repairContainer] Repair successful: ${outputFile.size} bytes`,
+				);
+			})(),
+			REPAIR_TIMEOUT_MS,
+			() => killProcess(proc),
+		);
+
+		return repairedFile;
+	} catch (err) {
+		await repairedFile.cleanup();
+		throw err;
+	} finally {
+		if (abortCleanup) {
+			abortSignal?.removeEventListener("abort", abortCleanup);
+		}
+		killProcess(proc);
+	}
+}
+
+export interface ResilientInputFlags {
+	errDetectIgnoreErr?: boolean;
+	genPts?: boolean;
+	discardCorrupt?: boolean;
+	maxMuxingQueueSize?: number;
+}
+
+function buildExtraInputFlags(flags: ResilientInputFlags): string[] {
+	const args: string[] = [];
+
+	if (flags.errDetectIgnoreErr) {
+		args.push("-err_detect", "ignore_err");
+	}
+
+	const fflags: string[] = [];
+	if (flags.genPts) fflags.push("+genpts");
+	if (flags.discardCorrupt) fflags.push("+discardcorrupt");
+	if (fflags.length > 0) {
+		args.push("-fflags", fflags.join(""));
+	}
+
+	return args;
+}
+
+function buildExtraOutputFlags(flags: ResilientInputFlags): string[] {
+	if (flags.maxMuxingQueueSize) {
+		return ["-max_muxing_queue_size", flags.maxMuxingQueueSize.toString()];
+	}
+	return [];
+}
+
 export async function processVideo(
 	inputPath: string,
 	metadata: VideoMetadata,
 	options: VideoProcessingOptions = {},
 	onProgress?: ProgressCallback,
 	abortSignal?: AbortSignal,
+	resilientFlags?: ResilientInputFlags,
 ): Promise<TempFileHandle> {
 	const definedOptions = Object.fromEntries(
 		Object.entries(options).filter(([, v]) => v !== undefined),
@@ -235,7 +349,21 @@ export async function processVideo(
 		: needsVideoTranscode(metadata, opts);
 	const audioTranscode = remuxOnly ? false : needsAudioTranscode(metadata);
 
-	const ffmpegArgs: string[] = ["ffmpeg", "-threads", "2", "-i", inputPath];
+	const extraInputArgs = resilientFlags
+		? buildExtraInputFlags(resilientFlags)
+		: [];
+	const extraOutputArgs = resilientFlags
+		? buildExtraOutputFlags(resilientFlags)
+		: [];
+
+	const ffmpegArgs: string[] = [
+		"ffmpeg",
+		"-threads",
+		"2",
+		...extraInputArgs,
+		"-i",
+		inputPath,
+	];
 
 	if (videoTranscode) {
 		ffmpegArgs.push(
@@ -265,6 +393,7 @@ export async function processVideo(
 	ffmpegArgs.push(
 		"-movflags",
 		"+faststart",
+		...extraOutputArgs,
 		"-progress",
 		"pipe:2",
 		"-y",

apps/media-server/src/lib/ffmpeg-video.ts

@@ -190,6 +190,92 @@ export async function probeVideo(videoUrl: string): Promise<VideoMetadata> {
 	}
 }
 
+export async function probeVideoFile(filePath: string): Promise<VideoMetadata> {
+	if (!canAcceptNewProbeProcess()) {
+		throw new Error("Server is busy, please try again later");
+	}
+
+	activeProbeProcesses++;
+
+	const proc = spawn({
+		cmd: [
+			"ffprobe",
+			"-v",
+			"quiet",
+			"-print_format",
+			"json",
+			"-show_format",
+			"-show_streams",
+			"-analyzeduration",
+			"10000000",
+			"-probesize",
+			"10000000",
+			filePath,
+		],
+		stdout: "pipe",
+		stderr: "ignore",
+	});
+
+	try {
+		const result = await withTimeout(
+			(async () => {
+				const stdoutText = await readStreamToString(
+					proc.stdout as ReadableStream<Uint8Array>,
+					MAX_OUTPUT_BYTES,
+				);
+
+				const exitCode = await proc.exited;
+
+				if (exitCode !== 0) {
+					throw new Error(`ffprobe exited with code ${exitCode}`);
+				}
+
+				const data: FFprobeOutput = JSON.parse(stdoutText);
+
+				console.log(
+					`[probeVideoFile] ffprobe output for ${filePath}: format=${JSON.stringify(data.format)}, streams=${data.streams?.length ?? 0}`,
+				);
+
+				const videoStream = data.streams?.find((s) => s.codec_type === "video");
+				const audioStream = data.streams?.find((s) => s.codec_type === "audio");
+
+				if (!videoStream) {
+					throw new Error("No video stream found");
+				}
+
+				const duration = Number.parseFloat(data.format?.duration ?? "0");
+				const fileSize = Number.parseInt(data.format?.size ?? "0", 10);
+				const bitrate = Number.parseInt(data.format?.bit_rate ?? "0", 10);
+				const fps =
+					parseFrameRate(videoStream.r_frame_rate) ||
+					parseFrameRate(videoStream.avg_frame_rate);
+
+				return {
+					duration,
+					width: videoStream.width ?? 0,
+					height: videoStream.height ?? 0,
+					fps: Math.round(fps * 100) / 100,
+					videoCodec: videoStream.codec_name ?? "unknown",
+					audioCodec: audioStream?.codec_name ?? null,
+					audioChannels: audioStream?.channels ?? null,
+					sampleRate: audioStream?.sample_rate
+						? Number.parseInt(audioStream.sample_rate, 10)
+						: null,
+					bitrate,
+					fileSize,
+				};
+			})(),
+			PROBE_TIMEOUT_MS,
+			() => killProcess(proc),
+		);
+
+		return result;
+	} finally {
+		activeProbeProcesses--;
+		killProcess(proc);
+	}
+}
+
 export async function checkVideoAccessible(videoUrl: string): Promise<boolean> {
 	try {
 		const response = await fetch(videoUrl, {