Merge pull request #240 from frankekn/upstream/video-duration

feat(obs): carry a video's length through the E2EE upload

Author: EdamAme-x

packages/linejs/base/obs/mod.ts

@@ -334,8 +334,14 @@ export class LineObs {
 		filename?: string;
 		/** Optional thumbnail; encrypted with the same keyMaterial. #103. */
 		preview?: Blob;
+		/**
+		 * Clip length in milliseconds, rounded to an integer for video `DURATION`.
+		 * Omitted unless the rounded value is a positive safe integer. Ignored for
+		 * other media types. The duration is caller-supplied, not inferred from data.
+		 */
+		durationMs?: number;
 	}): Promise<Message> {
-		const { data, oType, to, filename, preview } = options;
+		const { data, oType, to, filename, preview, durationMs } = options;
 		const typeSet: {
 			image: [string, 1];
 			video: [string, 2];
@@ -412,6 +418,18 @@ export class LineObs {
 			contentType,
 		);
 
+		// obs only ever sees the encrypted blob here, so it cannot read the length
+		// out of the container the way it does for a plain upload; without this
+		// LINE clients render the video as a 0:00 clip.
+		const roundedDuration = typeof durationMs === "number"
+			? Math.round(durationMs)
+			: NaN;
+		const durationMetadata: Record<string, string> =
+			oType === "video" && Number.isSafeInteger(roundedDuration) &&
+				roundedDuration > 0
+				? { DURATION: roundedDuration.toString() }
+				: {};
+
 		return await this.client.talk.sendMessage({
 			to,
 			chunks,
@@ -433,6 +451,7 @@ export class LineObs {
 						),
 					}
 					: {},
+				...durationMetadata,
 			},
 		});
 	}

packages/linejs/base/obs/upload_e2ee.test.ts

@@ -112,3 +112,156 @@ Deno.test("uploadMediaByE2EE — file type → no preview upload at all", async
 	});
 	assertEquals(fake.records.length, 1);
 });
+
+/** contentMetadata of the one sendMessage the upload ends with. */
+function sentMetadata(
+	fake: ReturnType<typeof fakeClient>,
+): Record<string, string> {
+	assertEquals(fake.sendMessageCalls.length, 1);
+	return (fake.sendMessageCalls[0] as {
+		contentMetadata: Record<string, string>;
+	}).contentMetadata;
+}
+
+Deno.test("uploadMediaByE2EE — a video carries its length as DURATION", async () => {
+	const { obs, fake } = makeObs();
+	await obs.uploadMediaByE2EE({
+		data: new Blob([new Uint8Array(1_000)]),
+		oType: "video",
+		to: "u-recipient",
+		durationMs: 4200.4,
+	});
+	assertEquals(sentMetadata(fake).DURATION, "4200");
+});
+
+Deno.test("uploadMediaByE2EE — no DURATION when omitted, none on an image", async () => {
+	const video = makeObs();
+	await video.obs.uploadMediaByE2EE({
+		data: new Blob([new Uint8Array(1_000)]),
+		oType: "video",
+		to: "u-recipient",
+	});
+	assertEquals(sentMetadata(video.fake).DURATION, undefined);
+
+	const image = makeObs();
+	await image.obs.uploadMediaByE2EE({
+		data: new Blob([new Uint8Array(1_000)]),
+		oType: "image",
+		to: "u-recipient",
+		durationMs: 4200,
+	});
+	assertEquals(sentMetadata(image.fake).DURATION, undefined);
+});
+
+Deno.test("uploadMediaByE2EE — a non-positive or non-finite duration is dropped", async () => {
+	for (const durationMs of [0, -1, NaN, Infinity]) {
+		const { obs, fake } = makeObs();
+		await obs.uploadMediaByE2EE({
+			data: new Blob([new Uint8Array(1_000)]),
+			oType: "video",
+			to: "u-recipient",
+			durationMs,
+		});
+		assertEquals(sentMetadata(fake).DURATION, undefined);
+	}
+});
+
+Deno.test("uploadMediaByE2EE — rounded zero and unsafe durations are omitted", async () => {
+	for (
+		const durationMs of [
+			0.1,
+			0.49,
+			Number.MIN_VALUE,
+			-Infinity,
+			Number.MAX_SAFE_INTEGER + 1,
+			1e21,
+			Number.MAX_VALUE,
+		]
+	) {
+		const { obs, fake } = makeObs();
+		await obs.uploadMediaByE2EE({
+			data: new Blob(["video"]),
+			oType: "video",
+			to: "u-recipient",
+			durationMs,
+		});
+		assertEquals(
+			sentMetadata(fake).DURATION,
+			undefined,
+			`durationMs=${durationMs}`,
+		);
+	}
+});
+
+Deno.test("uploadMediaByE2EE — rounds valid durations to positive integer milliseconds", async () => {
+	for (
+		const [durationMs, expected] of [[0.5, "1"], [1, "1"], [4200.5, "4201"], [
+			Number.MAX_SAFE_INTEGER,
+			"9007199254740991",
+		]] as const
+	) {
+		const { obs, fake } = makeObs();
+		await obs.uploadMediaByE2EE({
+			data: new Blob(["video"]),
+			oType: "video",
+			to: "u-recipient",
+			durationMs,
+		});
+		assertEquals(sentMetadata(fake).DURATION, expected);
+	}
+});
+
+Deno.test("uploadMediaByE2EE — duration does not change non-video metadata", async () => {
+	for (const oType of ["audio", "file", "image", "gif"] as const) {
+		const withDuration = makeObs();
+		const withoutDuration = makeObs();
+		const options = { data: new Blob(["media"]), oType, to: "u-recipient" };
+		await withDuration.obs.uploadMediaByE2EE({ ...options, durationMs: 4200 });
+		await withoutDuration.obs.uploadMediaByE2EE(options);
+		assertEquals(
+			sentMetadata(withDuration.fake),
+			sentMetadata(withoutDuration.fake),
+		);
+	}
+});
+
+Deno.test("uploadMediaByE2EE — video duration preserves encrypted preview and message metadata", async () => {
+	const { obs, fake } = makeObs();
+	await obs.uploadMediaByE2EE({
+		data: new Blob([new Uint8Array(1000)], { type: "video/mp4" }),
+		oType: "video",
+		to: "c-group",
+		filename: "clip.mp4",
+		preview: new Blob([new Uint8Array(20)]),
+		durationMs: 4200,
+	});
+	const metadata = sentMetadata(fake);
+	assertEquals(metadata, {
+		SID: "emv",
+		OID: "OBJ-1",
+		FILE_SIZE: "1032",
+		e2eeVersion: "2",
+		DURATION: "4200",
+		MEDIA_CONTENT_INFO: JSON.stringify({
+			category: "original",
+			fileSize: 1032,
+			extension: "mp4",
+			animated: false,
+		}),
+	});
+	assertEquals(fake.records.map((record) => record.size), [1032, 52]);
+	assert(fake.records[0].obsPath.startsWith("talk/emv/reqid-"));
+	assertEquals(fake.records[1].obsPath, "talk/emv/OBJ-1__ud-preview");
+	assertEquals(
+		fake.e2eeCalls[1].keyMaterial,
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
+	);
+	const message = fake.sendMessageCalls[0] as {
+		to: string;
+		contentType: number;
+		chunks: Uint8Array[];
+	};
+	assertEquals(message.to, "c-group");
+	assertEquals(message.contentType, 2);
+	assertEquals(message.chunks, [new Uint8Array()]);
+});