fix: preserve stored audio tail duration during recording remux

Author: richiemcilroy

apps/media-server/src/__tests__/lib/recording-verification.integration.test.ts

@@ -489,7 +489,18 @@ afterAll(async () => {
 });
 
 describe("encoded recording preservation", () => {
-	test("verifies looped AAC through decoded evidence when edit-list rounding changes the tail", async () => {
+	test("uses decoded source evidence for tied terminal video samples", async () => {
+		const input = await tiedTimestampSource("packet-tied-terminal.mp4", 2);
+		const output = join(directory, "packet-tied-terminal-output.mp4");
+		await muxMediaTracksToMp4(input, silent, output);
+		const verified = await verifyRemuxedRecording(input, silent, output, {
+			requireAudio: true,
+		});
+		expect(verified.sourcePreserved).toBe(true);
+		expect(verified.integrity).toBeDefined();
+		expect(verified.video.frameCount).toBe(40);
+	});
+	test("preserves the stored looped AAC tail for one complete output decode", async () => {
 		const input = join(directory, "looped-audio.mp4");
 		const output = join(directory, "looped-audio-remux.mp4");
 		await run([
@@ -510,6 +521,7 @@ describe("encoded recording preservation", () => {
 		});
 		expect(verified.fullDecode).toBe(true);
 		expect(verified.sourcePreserved).toBe(true);
+		expect(verified.integrity).toBeUndefined();
 		const source = await inspectRecordingSources(input, input);
 		expect(verified.audio).toEqual(source.audio);
 		expect(verified.video).toEqual(source.video);
@@ -593,7 +605,7 @@ describe("encoded recording preservation", () => {
 			}),
 		).rejects.toThrow();
 	});
-	test("retains the strict fallback for packet transformations", async () => {
+	test("preserves a shorter audio track independently of the video", async () => {
 		const output = join(directory, "proof-short-audio.mp4");
 		await muxMediaTracksToMp4(silent, shortAudio, output);
 		const verified = await verifyRemuxedRecording(silent, shortAudio, output, {
@@ -803,8 +815,10 @@ describe("complete recording decode", () => {
 				);
 				expect(source.video).toEqual(stock.video);
 				expect(source.audio).toEqual(stock.audio);
+				const output = join(directory, "long-recording-remux.mp4");
+				await muxMediaTracksToMp4(input, input, output);
 				const efficientStarted = performance.now();
-				const efficient = await verifyRemuxedRecording(input, input, input, {
+				const efficient = await verifyRemuxedRecording(input, input, output, {
 					requireAudio: true,
 					timeoutMs: 30_000,
 				});

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

@@ -14,6 +14,7 @@ import {
 } from "./media-common";
 import { probeVideoFile } from "./media-probe";
 import { fetchMedia, materializeMedia } from "./media-transfer";
+import { readRecordingAudioTail } from "./recording-packet-proof";
 import {
 	RecordingTimingError,
 	readRecordingVideoTiming,
@@ -2474,6 +2475,10 @@ export async function muxMediaTracksToMp4(
 	abortSignal?: AbortSignal,
 ): Promise<void> {
 	if (abortSignal?.aborted) throw new Error("Recording mux was cancelled");
+	abortSignal = AbortSignal.any([
+		...(abortSignal ? [abortSignal] : []),
+		AbortSignal.timeout(PROCESS_TIMEOUT_MS),
+	]);
 	const startedAt = performance.now();
 	const timing = await readRecordingVideoTiming(videoInputPath, {
 		abortSignal,
@@ -2483,6 +2488,15 @@ export async function muxMediaTracksToMp4(
 	const lastTimestamp = timing.lastTimestampTicks - timing.firstTimestampTicks;
 	// FFmpeg 7 can discard a fragmented MP4's stored final sample duration.
 	const videoTimingFilter = `setts=pts=PTS:dts=DTS:duration=if(eq(PTS-STARTPTS\\,${lastTimestamp})\\,${timing.lastDurationTicks}\\,DURATION)`;
+	const audioTiming = audioInputPath
+		? await readRecordingAudioTail(audioInputPath, abortSignal, true)
+		: undefined;
+	if (audioTiming && audioTiming.packetCount === undefined)
+		throw new Error("Recording audio packet count is missing");
+	// FFmpeg synthesizes nominal AAC durations, so bind the final duration to the stored source sample.
+	const audioTimingFilter = audioTiming?.packetCount
+		? `setts=duration=if(eq(N\\,${audioTiming.packetCount - 1})\\,${audioTiming.durationTicks}\\,DURATION)`
+		: undefined;
 	const args = audioInputPath
 		? [
 				"ffmpeg",
@@ -2501,6 +2515,7 @@ export async function muxMediaTracksToMp4(
 				"copy",
 				"-bsf:v",
 				videoTimingFilter,
+				...(audioTimingFilter ? ["-bsf:a", audioTimingFilter] : []),
 				"-avoid_negative_ts",
 				"disabled",
 				"-movie_timescale",

apps/media-server/src/lib/recording-packet-proof.ts

@@ -116,7 +116,11 @@ function time(value: string | undefined, base: string) {
 	return `${numerator / a}/${BigInt(match[2]) / a}`;
 }
 
-async function readAudioTail(path: string, signal: AbortSignal) {
+export async function readRecordingAudioTail(
+	path: string,
+	signal: AbortSignal,
+	countPackets = false,
+) {
 	const input = new Input({ formats: [MP4], source: new FilePathSource(path) });
 	const dispose = () => input.dispose();
 	signal.addEventListener("abort", dispose, { once: true });
@@ -155,8 +159,24 @@ async function readAudioTail(path: string, signal: AbortSignal) {
 			packet.sequenceNumber < 0
 		)
 			throw new Error("Recording audio duration is not exact");
+		const packetCount = countPackets
+			? (
+					await tracks[0].computePacketStats(Number.POSITIVE_INFINITY, {
+						metadataOnly: true,
+						skipLiveWait: true,
+					})
+				).packetCount
+			: undefined;
+		if (
+			packetCount !== undefined &&
+			(!Number.isSafeInteger(packetCount) || packetCount <= 0)
+		)
+			throw new Error("Recording audio packet count is invalid");
 		signal.throwIfAborted();
 		return {
+			packetCount,
+			durationTicks: ticks,
+			timeScale: scale,
 			size: packet.byteLength,
 			duration: time(String(ticks), `1/${scale}`),
 			hash: `SHA256:${createHash("sha256").update(packet.data).digest("hex")}`,
@@ -221,7 +241,8 @@ async function readTrack(
 	const startTime = startNumerator / startDenominator;
 	if (!Number.isFinite(startTime))
 		throw new Error("Recording start time is invalid");
-	const tail = kind === "audio" ? await readAudioTail(path, signal) : undefined;
+	const tail =
+		kind === "audio" ? await readRecordingAudioTail(path, signal) : undefined;
 	const hash = createHash("sha256");
 	let count = 0;
 	let pendingPacket: Record<string, string> | undefined;