fix(player): reuse legacy audio mp4 downloads

Author: chhoumann

src/downloadEpisode.ts

@@ -14,9 +14,11 @@ import getUrlExtension from "./utility/getUrlExtension";
 import getExtensionFromContentType from "./utility/getExtensionFromContentType";
 import {
 	getEpisodeMediaType,
+	getEpisodeMediaTypeWithAudioContainerHint,
 	getMediaTypeFromContentType,
 	getMediaTypeFromExtension,
 	getMediaTypeFromPath,
+	isAudioContainerExtension,
 	isPlayableMediaExtension,
 	isSameMediaSource,
 } from "./utility/mediaType";
@@ -357,10 +359,7 @@ function isExplicitAudioContainer(
 	extension: string | null | undefined,
 	mediaTypeHint?: EpisodeMediaType,
 ): boolean {
-	if (mediaTypeHint !== "audio" || !extension) return false;
-
-	const normalizedExtension = extension.toLowerCase();
-	return normalizedExtension === "mp4" || normalizedExtension === "webm";
+	return mediaTypeHint === "audio" && isAudioContainerExtension(extension);
 }
 
 function normalizeAudioExtension(
@@ -377,26 +376,6 @@ function normalizeAudioExtension(
 	return extension;
 }
 
-function getRegisteredEpisodeMediaType(
-	episode: Episode & { filePath?: string },
-	currentEpisodeMediaTypeHint?: EpisodeMediaType,
-): EpisodeMediaType {
-	if (episode.mediaType) return episode.mediaType;
-	const fileExtension = episode.filePath
-		? getUrlExtension(episode.filePath)
-		: null;
-	if (
-		isExplicitAudioContainer(
-			fileExtension,
-			currentEpisodeMediaTypeHint,
-		)
-	) {
-		return "audio";
-	}
-
-	return getEpisodeMediaType(episode);
-}
-
 /**
  * UNUSED IN PRODUCTION — kept only for the #178 tests. Do NOT use this for
  * transcription: it derives the on-disk path from the download-path template and
@@ -527,7 +506,7 @@ export async function getEpisodeAudioBuffer(
 		registered?.filePath &&
 		isSameMediaSource(registered.streamUrl, episode.streamUrl)
 	) {
-		const registeredMediaType = getRegisteredEpisodeMediaType(
+		const registeredMediaType = getEpisodeMediaTypeWithAudioContainerHint(
 			registered,
 			episode.mediaType === "audio" ? episodeMediaType : undefined,
 		);

src/ui/PodcastView/EpisodePlayer.svelte

@@ -40,6 +40,7 @@
 	} from "src/utility/playbackRate";
 	import {
 		getEpisodeMediaType,
+		getEpisodeMediaTypeWithAudioContainerHint,
 		isSameMediaSource,
 	} from "src/utility/mediaType";
 	import type DownloadedEpisode from "src/types/DownloadedEpisode";
@@ -392,7 +393,7 @@
 		if (shouldUseDownloadedEpisode(episode, downloadedEpisode)) {
 			return {
 				src: createMediaUrlObjectFromFilePath(downloadedEpisode.filePath),
-				mediaType: getEpisodeMediaType(downloadedEpisode),
+				mediaType: getDownloadedEpisodeMediaType(episode, downloadedEpisode),
 			};
 		}
 
@@ -417,7 +418,10 @@
 	): downloadedEpisode is DownloadedEpisode {
 		if (!downloadedEpisode?.filePath) return false;
 
-		const downloadedMediaType = getEpisodeMediaType(downloadedEpisode);
+		const downloadedMediaType = getDownloadedEpisodeMediaType(
+			episode,
+			downloadedEpisode,
+		);
 		if (episode.mediaType && downloadedMediaType !== episode.mediaType) {
 			return false;
 		}
@@ -430,6 +434,16 @@
 		return isSameMediaSource(downloadedEpisode.streamUrl, episode.streamUrl);
 	}
 
+	function getDownloadedEpisodeMediaType(
+		episode: Episode,
+		downloadedEpisode: DownloadedEpisode,
+	): EpisodeMediaType {
+		return getEpisodeMediaTypeWithAudioContainerHint(
+			downloadedEpisode,
+			episode.mediaType === "audio" ? "audio" : undefined,
+		);
+	}
+
 	$: if (mediaElement && mediaElement.playbackRate !== $playbackRate) {
 		mediaElement.playbackRate = $playbackRate;
 	}

src/ui/PodcastView/EpisodePlayer.test.ts

@@ -336,6 +336,39 @@ describe("EpisodePlayer", () => {
 		expect(video.getAttribute("src")).toBe(videoEpisode.streamUrl);
 	});
 
+	test("uses a legacy downloaded audio mp4 file for an explicitly audio feed episode", async () => {
+		mockVaultFile("Downloads/legacy-audio.mp4");
+		const audioEpisode: Episode = {
+			...testEpisode,
+			title: "Legacy Audio MP4",
+			streamUrl: "https://cdn.example.com/episode.mp4",
+			mediaType: "audio",
+		};
+		downloadedEpisodes.set({
+			[testEpisode.podcastName]: [
+				{
+					...testEpisode,
+					title: "Legacy Audio MP4",
+					streamUrl: "https://cdn.example.com/episode.mp4",
+					filePath: "Downloads/legacy-audio.mp4",
+					size: 10,
+				},
+			],
+		});
+		currentEpisode.set(audioEpisode);
+
+		const { container } = render(EpisodePlayer);
+		await waitFor(() => {
+			expect(container.querySelector("audio")).not.toBeNull();
+		});
+		const audio = container.querySelector("audio") as HTMLAudioElement;
+
+		expect(container.querySelector("video")).toBeNull();
+		expect(audio.getAttribute("src")).toBe(
+			"app://resource/Downloads/legacy-audio.mp4?token",
+		);
+	});
+
 	test("uses a matching downloaded video file to classify old extensionless records", async () => {
 		mockVaultFile("Downloads/video.mp4");
 		const extensionlessEpisode: Episode = {

src/utility/mediaType.test.ts

@@ -3,6 +3,7 @@ import type { Episode } from "src/types/Episode";
 import type { LocalEpisode } from "src/types/LocalEpisode";
 import {
 	getEpisodeMediaType,
+	getEpisodeMediaTypeWithAudioContainerHint,
 	getMediaTypeFromContentType,
 	isSameMediaSource,
 } from "./mediaType";
@@ -87,6 +88,40 @@ describe("mediaType", () => {
 		expect(getEpisodeMediaType(episode)).toBe("audio");
 	});
 
+	test("uses an audio hint for legacy ambiguous container file paths", () => {
+		const episode = {
+			title: "Legacy Downloaded Audio MP4",
+			streamUrl: "https://example.com/episode.mp4",
+			url: "https://example.com/episode",
+			description: "",
+			content: "",
+			podcastName: "Feed",
+			filePath: "Podcasts/downloaded-audio.mp4",
+		} satisfies Episode & { filePath: string };
+
+		expect(getEpisodeMediaType(episode)).toBe("video");
+		expect(getEpisodeMediaTypeWithAudioContainerHint(episode, "audio")).toBe(
+			"audio",
+		);
+	});
+
+	test("does not let an audio hint override explicit video metadata", () => {
+		const episode = {
+			title: "Downloaded Video MP4",
+			streamUrl: "https://example.com/episode.mp4",
+			url: "https://example.com/episode",
+			description: "",
+			content: "",
+			podcastName: "Feed",
+			mediaType: "video",
+			filePath: "Podcasts/downloaded-video.mp4",
+		} satisfies Episode & { filePath: string };
+
+		expect(getEpisodeMediaTypeWithAudioContainerHint(episode, "audio")).toBe(
+			"video",
+		);
+	});
+
 	test("trusts remote episode media metadata before URL extension fallback", () => {
 		expect(
 			getEpisodeMediaType({

src/utility/mediaType.ts

@@ -72,6 +72,33 @@ export function getEpisodeMediaType(episode: Episode): EpisodeMediaType {
 	return getMediaTypeFromPath(episode.streamUrl) ?? "audio";
 }
 
+export function isAudioContainerExtension(
+	extension?: string | null,
+): boolean {
+	if (!extension) return false;
+
+	const normalizedExtension = extension.toLowerCase();
+	return normalizedExtension === "mp4" || normalizedExtension === "webm";
+}
+
+export function getEpisodeMediaTypeWithAudioContainerHint(
+	episode: Episode,
+	mediaTypeHint?: EpisodeMediaType,
+): EpisodeMediaType {
+	if (episode.mediaType) return episode.mediaType;
+
+	const filePath = (episode as Partial<LocalEpisode>).filePath;
+	const fileExtension = filePath ? getUrlExtension(filePath) : null;
+	if (
+		mediaTypeHint === "audio" &&
+		isAudioContainerExtension(fileExtension)
+	) {
+		return "audio";
+	}
+
+	return getEpisodeMediaType(episode);
+}
+
 export function isSameMediaSource(a: string, b: string): boolean {
 	if (a === b) return true;
 	if (!a || !b) return false;