Fix embedded audio fallback handling and audio diagnostics

electron/ipc/recording/windowsFallbacks.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+
+import { shouldUseWindowsBrowserMicrophoneFallback } from "./windowsFallbacks";
+
+describe("shouldUseWindowsBrowserMicrophoneFallback", () => {
+	it("returns true when native Windows mic initialization fails", () => {
+		expect(
+			shouldUseWindowsBrowserMicrophoneFallback(
+				"WARNING: Failed to initialize WASAPI mic capture\nRecording started",
+				{ capturesMicrophone: true },
+			),
+		).toBe(true);
+	});
+
+	it("returns false when microphone capture was not requested", () => {
+		expect(
+			shouldUseWindowsBrowserMicrophoneFallback(
+				"WARNING: Failed to initialize WASAPI mic capture\nRecording started",
+				{ capturesMicrophone: false },
+			),
+		).toBe(false);
+	});
+});

electron/ipc/recording/windowsFallbacks.ts

@@ -0,0 +1,11 @@
+const WINDOWS_MIC_CAPTURE_INIT_WARNING = "WARNING: Failed to initialize WASAPI mic capture";
+
+export function shouldUseWindowsBrowserMicrophoneFallback(
+	captureOutput: string,
+	options?: { capturesMicrophone?: boolean },
+) {
+	return (
+		Boolean(options?.capturesMicrophone) &&
+		captureOutput.includes(WINDOWS_MIC_CAPTURE_INIT_WARNING)
+	);
+}

electron/ipc/register/recording.ts

@@ -93,6 +93,7 @@ import {
 	attachWindowsCaptureLifecycle,
 	muxNativeWindowsVideoWithAudio,
 } from "../recording/windows";
+import { shouldUseWindowsBrowserMicrophoneFallback } from "../recording/windowsFallbacks";
 import {
 	waitForNativeCaptureStart,
 	waitForNativeCaptureStop,
@@ -189,6 +190,9 @@ export function registerRecordingHandlers(
         const recordingsDir = await getRecordingsDir()
         const timestamp = Date.now()
         const outputPath = path.join(recordingsDir, `recording-${timestamp}.mp4`)
+        let captureOutput = ''
+        let systemAudioPath: string | null = null
+        let microphonePath: string | null = null
         const displayBounds = source?.id?.startsWith('window:') ? null : getDisplayBoundsForSource(source)
 
         const config: Record<string, unknown> = {
@@ -197,20 +201,20 @@ export function registerRecordingHandlers(
         }
 
         if (options?.capturesSystemAudio) {
-          const audioPath = path.join(recordingsDir, `recording-${timestamp}.system.wav`)
+          systemAudioPath = path.join(recordingsDir, `recording-${timestamp}.system.wav`)
           config.captureSystemAudio = true
-          config.audioOutputPath = audioPath
-          setWindowsSystemAudioPath(audioPath)
+          config.audioOutputPath = systemAudioPath
+          setWindowsSystemAudioPath(systemAudioPath)
         }
 
         if (options?.capturesMicrophone) {
-          const micPath = path.join(recordingsDir, `recording-${timestamp}.mic.wav`)
+          microphonePath = path.join(recordingsDir, `recording-${timestamp}.mic.wav`)
           config.captureMic = true
-          config.micOutputPath = micPath
+          config.micOutputPath = microphonePath
           if (options.microphoneLabel) {
             config.micDeviceName = options.microphoneLabel
           }
-          setWindowsMicAudioPath(micPath)
+          setWindowsMicAudioPath(microphonePath)
         }
 
         const windowId = parseWindowId(source?.id)
@@ -242,8 +246,8 @@ export function registerRecordingHandlers(
           windowHandle: typeof config.windowHandle === 'number' ? config.windowHandle : null,
           helperPath: exePath,
           outputPath,
-          systemAudioPath: windowsSystemAudioPath,
-          microphonePath: windowsMicAudioPath,
+          systemAudioPath,
+          microphonePath,
         })
 
         setWindowsCaptureOutputBuffer('')
@@ -258,13 +262,23 @@ export function registerRecordingHandlers(
         attachWindowsCaptureLifecycle(wcProc)
 
         wcProc.stdout.on('data', (chunk: Buffer) => {
-          setWindowsCaptureOutputBuffer(windowsCaptureOutputBuffer + chunk.toString())
+          captureOutput += chunk.toString()
+          setWindowsCaptureOutputBuffer(captureOutput)
         })
         wcProc.stderr.on('data', (chunk: Buffer) => {
-          setWindowsCaptureOutputBuffer(windowsCaptureOutputBuffer + chunk.toString())
+          captureOutput += chunk.toString()
+          setWindowsCaptureOutputBuffer(captureOutput)
         })
 
         await waitForWindowsCaptureStart(wcProc)
+        const microphoneFallbackRequired = shouldUseWindowsBrowserMicrophoneFallback(
+          captureOutput,
+          options,
+        )
+        if (microphoneFallbackRequired) {
+          microphonePath = null
+          setWindowsMicAudioPath(null)
+        }
         setWindowsNativeCaptureActive(true)
         setNativeScreenRecordingActive(true)
         recordNativeCaptureDiagnostics({
@@ -277,11 +291,11 @@ export function registerRecordingHandlers(
           windowHandle: typeof config.windowHandle === 'number' ? config.windowHandle : null,
           helperPath: exePath,
           outputPath,
-          systemAudioPath: windowsSystemAudioPath,
-          microphonePath: windowsMicAudioPath,
-          processOutput: windowsCaptureOutputBuffer.trim() || undefined,
+          systemAudioPath,
+          microphonePath,
+          processOutput: captureOutput.trim() || undefined,
         })
-        return { success: true }
+        return { success: true, microphoneFallbackRequired }
       } catch (error) {
         recordNativeCaptureDiagnostics({
           backend: 'windows-wgc',

src/components/video-editor/VideoEditor.tsx

@@ -63,6 +63,7 @@ import {
 	VideoExporter,
 } from "@/lib/exporter";
 import { resolveMediaElementSource } from "@/lib/exporter/localMediaSource";
+import { resolveSourceAudioFallbackPaths } from "@/lib/exporter/sourceAudioFallback";
 import {
 	clampMediaTimeToDuration,
 	estimateCompanionAudioStartDelaySeconds,
@@ -237,6 +238,7 @@ async function writeSmokeExportReport(
 }
 
 const DEFAULT_MP4_EXPORT_FRAME_RATE: ExportMp4FrameRate = 30;
+const SOURCE_AUDIO_FALLBACK_TOAST_ID = "source-audio-fallback-error";
 
 function getEncodingModeBitrateMultiplier(encodingMode: ExportEncodingMode): number {
 	switch (encodingMode) {
@@ -1202,7 +1204,15 @@ export default function VideoEditor() {
 		() => videoSourcePath ?? (videoPath ? fromFileUrl(videoPath) : null),
 		[videoPath, videoSourcePath],
 	);
-	const hasSourceAudioFallback = sourceAudioFallbackPaths.length > 0;
+	const {
+		hasEmbeddedSourceAudio,
+		externalAudioPaths: previewSourceAudioFallbackPaths,
+	} = useMemo(
+		() => resolveSourceAudioFallbackPaths(currentSourcePath, sourceAudioFallbackPaths),
+		[currentSourcePath, sourceAudioFallbackPaths],
+	);
+	const shouldMutePreviewVideo =
+		!hasEmbeddedSourceAudio && previewSourceAudioFallbackPaths.length > 0;
 
 	useEffect(() => {
 		let cancelled = false;
@@ -1221,10 +1231,26 @@ export default function VideoEditor() {
 				if (cancelled) {
 					return;
 				}
-				setSourceAudioFallbackPaths(result.success ? (result.paths ?? []) : []);
-			} catch {
+				if (!result.success) {
+					setSourceAudioFallbackPaths([]);
+					toast.warning(
+						result.error
+							? `Could not load companion audio sources: ${summarizeErrorMessage(result.error)}`
+							: "Could not load companion audio sources. Playback and export may miss microphone audio.",
+						{ id: SOURCE_AUDIO_FALLBACK_TOAST_ID, duration: 10000 },
+					);
+					return;
+				}
+
+				toast.dismiss(SOURCE_AUDIO_FALLBACK_TOAST_ID);
+				setSourceAudioFallbackPaths(result.paths ?? []);
+			} catch (error) {
 				if (!cancelled) {
 					setSourceAudioFallbackPaths([]);
+					toast.warning(
+						`Could not load companion audio sources: ${summarizeErrorMessage(String(error))}`,
+						{ id: SOURCE_AUDIO_FALLBACK_TOAST_ID, duration: 10000 },
+					);
 				}
 			}
 		})();
@@ -3434,7 +3460,7 @@ export default function VideoEditor() {
 	useEffect(() => {
 		let cancelled = false;
 		const existing = sourceAudioElementsRef.current;
-		const currentIds = new Set(sourceAudioFallbackPaths);
+		const currentIds = new Set(previewSourceAudioFallbackPaths);
 
 		for (const [id, audio] of existing) {
 			if (!currentIds.has(id)) {
@@ -3447,7 +3473,7 @@ export default function VideoEditor() {
 			}
 		}
 
-		for (const audioPath of sourceAudioFallbackPaths) {
+		for (const audioPath of previewSourceAudioFallbackPaths) {
 			let audio = existing.get(audioPath);
 			if (!audio) {
 				audio = new Audio();
@@ -3483,14 +3509,14 @@ export default function VideoEditor() {
 			audio.volume = Math.max(0, Math.min(1, previewVolume));
 		}
 
-		if (sourceAudioFallbackPaths.length === 0) {
+		if (previewSourceAudioFallbackPaths.length === 0) {
 			lastSourceAudioSyncTimeRef.current = null;
 		}
 
 		return () => {
 			cancelled = true;
 		};
-	}, [previewVolume, sourceAudioFallbackPaths]);
+	}, [previewSourceAudioFallbackPaths, previewVolume]);
 
 	useEffect(() => {
 		return () => {
@@ -3558,7 +3584,7 @@ export default function VideoEditor() {
 	}, [isPlaying, currentTime, audioRegions, speedRegions]);
 
 	useEffect(() => {
-		if (sourceAudioFallbackPaths.length === 0) {
+		if (previewSourceAudioFallbackPaths.length === 0) {
 			lastSourceAudioSyncTimeRef.current = null;
 			return;
 		}
@@ -3610,7 +3636,7 @@ export default function VideoEditor() {
 		}
 
 		lastSourceAudioSyncTimeRef.current = currentTime;
-	}, [currentTime, duration, isPlaying, sourceAudioFallbackPaths, speedRegions]);
+	}, [currentTime, duration, isPlaying, previewSourceAudioFallbackPaths, speedRegions]);
 
 	const showExportSuccessToast = useCallback((filePath: string) => {
 		toast.success(`Exported successfully to ${filePath}`, {
@@ -5159,7 +5185,7 @@ export default function VideoEditor() {
 													cursorClickBounceDuration
 												}
 												cursorSway={cursorSway}
-												volume={hasSourceAudioFallback ? 0 : previewVolume}
+												volume={shouldMutePreviewVideo ? 0 : previewVolume}
 											/>
 										</div>
 									</div>

src/components/video-editor/VideoPlayback.tsx

@@ -1458,7 +1458,11 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 			blurFilter.resolution = app.renderer.resolution;
 			blurFilter.blur = 0;
 			const motionBlurFilter = new MotionBlurFilter([0, 0], 5, 0);
-			videoContainer.filters = [blurFilter, motionBlurFilter];
+			// Don't attach filters by default — the filter pipeline forces the video
+			// through an intermediate RenderTexture at renderer resolution, downsampling
+			// the native video and destroying detail. Filters are attached conditionally
+			// in the ticker only when zoom motion blur is actually active.
+			videoContainer.filters = null;
 			blurFilterRef.current = blurFilter;
 			motionBlurFilterRef.current = motionBlurFilter;
 
@@ -1543,6 +1547,7 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 				const appliedTransform = applyZoomTransform({
 					cameraContainer,
 					blurFilter: blurFilterRef.current,
+					motionBlurFilter: motionBlurFilterRef.current,
 					stageSize: stageSizeRef.current,
 					baseMask: baseMaskRef.current,
 					zoomScale: state.scale,
@@ -1553,7 +1558,6 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 					motionVector,
 					isPlaying: isPlayingRef.current,
 					motionBlurAmount: zoomMotionBlurRef.current,
-					motionBlurFilter: motionBlurFilterRef.current,
 					transformOverride: transform,
 					motionBlurState: motionBlurStateRef.current,
 					frameTimeMs: performance.now(),
@@ -1738,6 +1742,21 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 					motionIntensity,
 					motionVector,
 				);
+
+				// Conditionally attach motion blur filter only when the camera is
+				// actually moving. When filters are attached, PixiJS routes the video
+				// through an intermediate RenderTexture at renderer resolution, which
+				// downsamples the native video and degrades preview quality.
+				// Hysteresis prevents flickering when motionIntensity oscillates near threshold.
+				const filtersActive = Array.isArray(videoContainer.filters) && videoContainer.filters.length > 0;
+				const cameraIsMoving = filtersActive ? motionIntensity > 0.002 : motionIntensity > 0.008;
+				const needsFilters = zoomMotionBlurRef.current > 0 && isPlayingRef.current && cameraIsMoving;
+				if (needsFilters && !filtersActive && motionBlurFilterRef.current) {
+					videoContainer.filters = [motionBlurFilterRef.current];
+				} else if (!needsFilters && filtersActive) {
+					videoContainer.filters = null;
+				}
+
 				applyWebcamBubbleLayout(animationStateRef.current.appliedScale || 1);
 
 				const timeMs = currentTimeRef.current;

src/hooks/useScreenRecorder.ts

@@ -33,6 +33,10 @@ const WEBCAM_WIDTH = 1280;
 const WEBCAM_HEIGHT = 720;
 const WEBCAM_FRAME_RATE = 30;
 const WEBCAM_SUFFIX = "-webcam";
+const SOURCE_AUDIO_MUX_TOAST_ID = "recording-audio-mux-warning";
+const MICROPHONE_FALLBACK_TOAST_ID = "recording-microphone-fallback";
+const MICROPHONE_FALLBACK_ERROR_TOAST_ID = "recording-microphone-fallback-error";
+const MICROPHONE_SIDECAR_ERROR_TOAST_ID = "recording-microphone-sidecar-error";
 const LINUX_PORTAL_SOURCE: ProcessedDesktopSource = {
 	id: "screen:linux-portal",
 	name: "Linux Portal",
@@ -76,6 +80,14 @@ type UseScreenRecorderReturn = {
 	setCountdownDelay: (delay: number) => void;
 };
 
+function getErrorMessage(error: unknown) {
+	if (error instanceof Error && error.message) {
+		return error.message;
+	}
+
+	return String(error);
+}
+
 export function useScreenRecorder(): UseScreenRecorderReturn {
 	const [recording, setRecording] = useState(false);
 	const [paused, setPaused] = useState(false);
@@ -443,9 +455,22 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 
 			try {
 				const arrayBuffer = await micFallbackBlob.arrayBuffer();
-				await window.electronAPI.storeMicrophoneSidecar(arrayBuffer, finalPath);
+				const result = await window.electronAPI.storeMicrophoneSidecar(arrayBuffer, finalPath);
+				if (!result.success) {
+					const errorMessage =
+						result.error || "Failed to save the fallback microphone audio track";
+					console.warn("Failed to store microphone sidecar:", errorMessage);
+					toast.error(
+						`${errorMessage}. Recording was saved without the fallback microphone track.`,
+						{ id: MICROPHONE_SIDECAR_ERROR_TOAST_ID, duration: 10000 },
+					);
+				}
 			} catch (error) {
 				console.warn("Failed to store microphone sidecar:", error);
+				toast.error(
+					`${getErrorMessage(error)}. Recording was saved without the fallback microphone track.`,
+					{ id: MICROPHONE_SIDECAR_ERROR_TOAST_ID, duration: 10000 },
+				);
 			}
 		},
 		[],
@@ -676,6 +701,14 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 						await window.electronAPI.muxNativeWindowsRecording(pauseSegments);
 					if (!muxResult?.success) {
 						void logNativeCaptureDiagnostics("mux-native-windows-recording");
+						const warningMessage =
+							muxResult?.error ||
+							muxResult?.message ||
+							"Failed to finish the native Windows audio mux";
+						toast.warning(
+							`${warningMessage}. Recording was saved, but audio playback or export may be incomplete.`,
+							{ id: SOURCE_AUDIO_MUX_TOAST_ID, duration: 10000 },
+						);
 					}
 					finalPath = muxResult?.path ?? result.path;
 				}
@@ -967,6 +1000,11 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 					// When native mic capture is unavailable (macOS < 14), record mic
 					// via browser getUserMedia so it can be saved as a sidecar file.
 					if (nativeResult.microphoneFallbackRequired && microphoneEnabled) {
+						void logNativeCaptureDiagnostics("start-browser-microphone-fallback");
+						toast.warning(
+							"Native microphone capture is unavailable. Using browser microphone fallback for this recording.",
+							{ id: MICROPHONE_FALLBACK_TOAST_ID, duration: 8000 },
+						);
 						try {
 							const micStream = await navigator.mediaDevices.getUserMedia({
 								audio: microphoneDeviceId
@@ -996,6 +1034,10 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 							micFallbackRecorder.current = recorder;
 						} catch (micError) {
 							console.warn("Browser microphone fallback failed:", micError);
+							toast.error(
+								`${getErrorMessage(micError)}. Recording will continue without microphone audio.`,
+								{ id: MICROPHONE_FALLBACK_ERROR_TOAST_ID, duration: 10000 },
+							);
 						}
 					}