XS⚠️ ◾ Check if video has audio before processing (#695)

* check if video has audio before processing

* fix biome format

* clean up

Author: babakamyljanovssw

src/backend/ipc/channels.ts

@@ -24,6 +24,7 @@ export const IPC_CHANNELS = {
   SHOW_CONTROL_BAR: "show-control-bar",
   HIDE_CONTROL_BAR: "hide-control-bar",
   RECORDING_TIME_UPDATE: "recording-time-update",
+  CHECK_VIDEO_HAS_AUDIO: "check-video-has-audio",
   MINIMIZE_MAIN_WINDOW: "minimize-main-window",
   RESTORE_MAIN_WINDOW: "restore-main-window",
   OPEN_SOURCE_PICKER: "open-source-picker",

src/backend/ipc/process-video-handlers.ts

@@ -240,6 +240,16 @@ export class ProcessVideoIPCHandlers {
       this.lastVideoFilePath = filePath;
       workflowManager.startStage(WorkflowProgressStage.CONVERTING_AUDIO);
       notify(ProgressStage.CONVERTING_AUDIO);
+
+      const hasAudio = await this.ffmpegService.hasAudibleAudio(filePath);
+      if (!hasAudio) {
+        const errorMessage =
+          "No audio detected in this video. Please re-record and make sure the correct microphone is selected and unmuted.";
+        workflowManager.failStage(WorkflowProgressStage.CONVERTING_AUDIO, errorMessage);
+        notify(ProgressStage.ERROR, { error: errorMessage });
+        return { success: false, error: errorMessage };
+      }
+
       const mp3FilePath = await this.convertVideoToMp3(filePath);
 
       workflowManager.completeStage(WorkflowProgressStage.CONVERTING_AUDIO);
@@ -251,6 +261,14 @@ export class ProcessVideoIPCHandlers {
       const transcript = await transcriptionModelProvider.transcribeAudio(mp3FilePath);
       const transcriptText = transcript.map((seg) => seg.text).join("");
 
+      if (!transcriptText.trim()) {
+        const errorMessage =
+          "No speech detected in this recording. Please re-record and check your microphone and audio levels.";
+        workflowManager.failStage(WorkflowProgressStage.TRANSCRIBING, errorMessage);
+        notify(ProgressStage.ERROR, { error: errorMessage });
+        return { success: false, error: errorMessage };
+      }
+
       notify(ProgressStage.TRANSCRIPTION_COMPLETED, { transcript });
 
       workflowManager.completeStage(WorkflowProgressStage.TRANSCRIBING, transcriptText);

src/backend/ipc/screen-recording-handlers.ts

@@ -1,16 +1,19 @@
 import { ipcMain } from "electron";
 import { getMainWindow } from "../index";
+import { FFmpegService } from "../services/ffmpeg/ffmpeg-service";
 import { CameraWindow } from "../services/recording/camera-window";
 import { RecordingControlBarWindow } from "../services/recording/control-bar-window";
 import { CountdownWindow } from "../services/recording/countdown-window";
 import { RecordingService } from "../services/recording/recording-service";
+import { formatErrorMessage } from "../utils/error-utils";
 import { IPC_CHANNELS } from "./channels";
 
 export class ScreenRecordingIPCHandlers {
   private service = RecordingService.getInstance();
   private controlBar = RecordingControlBarWindow.getInstance();
   private cameraWindow = CameraWindow.getInstance();
   private countdownWindow = CountdownWindow.getInstance();
+  private ffmpegService = FFmpegService.getInstance();
 
   constructor() {
     const handlers = {
@@ -28,6 +31,14 @@ export class ScreenRecordingIPCHandlers {
       [IPC_CHANNELS.STOP_RECORDING_FROM_CONTROL_BAR]: () => this.stopRecordingFromControlBar(),
       [IPC_CHANNELS.MINIMIZE_MAIN_WINDOW]: () => this.minimizeMainWindow(),
       [IPC_CHANNELS.RESTORE_MAIN_WINDOW]: () => this.restoreMainWindow(),
+      [IPC_CHANNELS.CHECK_VIDEO_HAS_AUDIO]: async (_: unknown, filePath: string) => {
+        try {
+          const hasAudio = await this.ffmpegService.hasAudibleAudio(filePath);
+          return { success: true, hasAudio };
+        } catch (error) {
+          return { success: false, error: formatErrorMessage(error) };
+        }
+      },
     };
 
     for (const [channel, handler] of Object.entries(handlers)) {

src/backend/preload.ts

@@ -42,6 +42,7 @@ const IPC_CHANNELS = {
   ENABLE_LOOPBACK_AUDIO: "enable-loopback-audio",
   DISABLE_LOOPBACK_AUDIO: "disable-loopback-audio",
   HIDE_CONTROL_BAR: "hide-control-bar",
+  CHECK_VIDEO_HAS_AUDIO: "check-video-has-audio",
   MINIMIZE_MAIN_WINDOW: "minimize-main-window",
   RESTORE_MAIN_WINDOW: "restore-main-window",
   OPEN_SOURCE_PICKER: "open-source-picker",
@@ -174,6 +175,8 @@ const electronAPI = {
     listSources: () => ipcRenderer.invoke(IPC_CHANNELS.LIST_SCREEN_SOURCES),
     cleanupTempFile: (filePath: string) =>
       ipcRenderer.invoke(IPC_CHANNELS.CLEANUP_TEMP_FILE, filePath),
+    hasAudio: (filePath: string) =>
+      ipcRenderer.invoke(IPC_CHANNELS.CHECK_VIDEO_HAS_AUDIO, filePath),
     showControlBar: (cameraDeviceId?: string) =>
       ipcRenderer.invoke(IPC_CHANNELS.SHOW_CONTROL_BAR, cameraDeviceId),
     hideControlBar: () => ipcRenderer.invoke(IPC_CHANNELS.HIDE_CONTROL_BAR),

src/backend/services/ffmpeg/ffmpeg-service.test.ts

@@ -207,6 +207,79 @@ describe("FFmpegService", () => {
     });
   });
 
+  describe("hasAudibleAudio", () => {
+    it("should resolve false when file has no audio stream", async () => {
+      const service = new FFmpegService("/mock/ffmpeg", mockFileSystem, mockProcessSpawner);
+
+      const resultPromise = service.hasAudibleAudio("/input/video.mp4");
+
+      setImmediate(() => {
+        mockChildProcess.stderr?.emit(
+          "data",
+          Buffer.from("Stream map '0:a:0' matches no streams.\n"),
+        );
+        mockChildProcess.emit("close", 1);
+      });
+
+      await expect(resultPromise).resolves.toBe(false);
+    });
+
+    it("should resolve false when max_volume is -inf dB", async () => {
+      const service = new FFmpegService("/mock/ffmpeg", mockFileSystem, mockProcessSpawner);
+
+      const resultPromise = service.hasAudibleAudio("/input/video.mp4");
+
+      setImmediate(() => {
+        mockChildProcess.stderr?.emit("data", Buffer.from("max_volume: -inf dB\n"));
+        mockChildProcess.emit("close", 0);
+      });
+
+      await expect(resultPromise).resolves.toBe(false);
+    });
+
+    it("should resolve false when max_volume is below threshold", async () => {
+      const service = new FFmpegService("/mock/ffmpeg", mockFileSystem, mockProcessSpawner);
+
+      const resultPromise = service.hasAudibleAudio("/input/video.mp4", -50);
+
+      setImmediate(() => {
+        mockChildProcess.stderr?.emit("data", Buffer.from("max_volume: -80.0 dB\n"));
+        mockChildProcess.emit("close", 0);
+      });
+
+      await expect(resultPromise).resolves.toBe(false);
+    });
+
+    it("should resolve true when max_volume meets threshold", async () => {
+      const service = new FFmpegService("/mock/ffmpeg", mockFileSystem, mockProcessSpawner);
+
+      const resultPromise = service.hasAudibleAudio("/input/video.mp4", -50);
+
+      setImmediate(() => {
+        mockChildProcess.stderr?.emit("data", Buffer.from("max_volume: -10.0 dB\n"));
+        mockChildProcess.emit("close", 0);
+      });
+
+      await expect(resultPromise).resolves.toBe(true);
+    });
+
+    it("should reject when ffmpeg audible-audio check fails for other reasons", async () => {
+      const service = new FFmpegService("/mock/ffmpeg", mockFileSystem, mockProcessSpawner);
+
+      const resultPromise = service.hasAudibleAudio("/input/video.mp4");
+
+      setImmediate(() => {
+        mockChildProcess.stderr?.emit(
+          "data",
+          Buffer.from("Invalid data found when processing input\n"),
+        );
+        mockChildProcess.emit("close", 1);
+      });
+
+      await expect(resultPromise).rejects.toThrow("FFmpeg audible-audio check failed with code 1");
+    });
+  });
+
   describe("getInstance", () => {
     it("should return the same instance (singleton)", () => {
       const instance1 = FFmpegService.getInstance();

src/backend/services/ffmpeg/ffmpeg-service.ts

@@ -111,6 +111,81 @@ export class FFmpegService {
     });
   }
 
+  async hasAudibleAudio(inputPath: string, minMaxVolumeDb = -50): Promise<boolean> {
+    await this.ensureInputFileExists(inputPath);
+    await this.ensureFfmpegExists();
+
+    return new Promise((resolve, reject) => {
+      const args = [
+        "-hide_banner",
+        "-nostats",
+        "-i",
+        inputPath,
+        "-map",
+        "0:a:0",
+        "-vn",
+        "-af",
+        "volumedetect",
+        "-f",
+        "null",
+        "-",
+      ];
+
+      const ffmpegProcess = this.processSpawner.spawn(this.ffmpegPath, args);
+      let stderr = "";
+
+      ffmpegProcess.stderr?.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      ffmpegProcess.on("close", (code: number | null) => {
+        if (code !== 0) {
+          const normalized = stderr.toLowerCase();
+          const indicatesNoAudio =
+            normalized.includes("matches no streams") ||
+            normalized.includes("does not contain any stream") ||
+            normalized.includes("stream map");
+
+          if (indicatesNoAudio) {
+            resolve(false);
+            return;
+          }
+
+          reject(
+            new Error(
+              `FFmpeg audible-audio check failed with code ${code ?? "unknown"}. Error: ${stderr || "Unknown error"}`,
+            ),
+          );
+          return;
+        }
+
+        const maxVolumeMatch = stderr.match(/max_volume:\s*(-?inf|[-\d.]+)\s*dB/i);
+        if (!maxVolumeMatch) {
+          resolve(false);
+          return;
+        }
+
+        const raw = maxVolumeMatch[1].toLowerCase();
+        if (raw === "-inf" || raw === "inf") {
+          resolve(false);
+          return;
+        }
+
+        const maxVolumeDb = Number.parseFloat(raw);
+        if (Number.isNaN(maxVolumeDb)) {
+          resolve(false);
+          return;
+        }
+
+        resolve(maxVolumeDb >= minMaxVolumeDb);
+      });
+
+      ffmpegProcess.on("error", (error: Error) => {
+        reject(new Error(`Failed to start FFmpeg: ${error.message}`));
+      });
+    });
+  }
+
   async captureNthFrame(
     inputPath: string,
     outputImagePath: string,

src/ui/src/components/recording/ScreenRecorder.tsx

@@ -136,6 +136,14 @@ export function ScreenRecorder() {
     }
 
     const { filePath, fileName } = recordedVideo;
+    const audioCheck = await window.electronAPI.screenRecording.hasAudio(filePath);
+    if (audioCheck?.success && audioCheck.hasAudio === false) {
+      toast.error(
+        "No audio detected in this recording. Please re-record and make sure the correct microphone is selected and unmuted.",
+      );
+      return;
+    }
+
     resetPreview();
 
     try {

src/ui/src/components/recording/VideoPreviewModal.tsx

@@ -41,6 +41,13 @@ export function VideoPreviewModal({
 }: VideoPreviewModalProps) {
   const [videoUrl, setVideoUrl] = useState("");
   const [showConfirmExit, setShowConfirmExit] = useState(false);
+  const [audioCheck, setAudioCheck] = useState<
+    | { status: "idle" }
+    | { status: "checking" }
+    | { status: "has_audio" }
+    | { status: "no_audio" }
+    | { status: "error"; error: string }
+  >({ status: "idle" });
 
   useEffect(() => {
     if (!videoBlob) return;
@@ -49,6 +56,32 @@ export function VideoPreviewModal({
     return () => URL.revokeObjectURL(url);
   }, [videoBlob]);
 
+  useEffect(() => {
+    if (!open) {
+      setAudioCheck({ status: "idle" });
+      return;
+    }
+
+    let cancelled = false;
+    const run = async () => {
+      setAudioCheck({ status: "checking" });
+      const result = await window.electronAPI.screenRecording.hasAudio(videoFilePath);
+      if (cancelled) return;
+
+      if (!result?.success) {
+        setAudioCheck({ status: "error", error: result?.error || "Audio check failed" });
+        return;
+      }
+
+      setAudioCheck(result.hasAudio ? { status: "has_audio" } : { status: "no_audio" });
+    };
+
+    run();
+    return () => {
+      cancelled = true;
+    };
+  }, [open, videoFilePath]);
+
   const cleanupFile = () => window.electronAPI.screenRecording.cleanupTempFile(videoFilePath);
 
   const confirmExit = async () => {
@@ -78,12 +111,26 @@ export function VideoPreviewModal({
             />
           )}
 
+          {audioCheck.status === "checking" && (
+            <p className="text-sm text-muted-foreground">Checking audio…</p>
+          )}
+          {audioCheck.status === "no_audio" && (
+            <div className="rounded-md border border-ssw-red/30 bg-ssw-red/10 px-3 py-2 text-sm text-ssw-red-foreground">
+              No audio detected in this recording. Please re-record and make sure the correct
+              microphone is selected and unmuted.
+            </div>
+          )}
+
           <DialogFooter className="gap-2">
             <Button variant="outline" onClick={handleRetry}>
               <RotateCcw className="w-4 h-4" />
               Re-record
             </Button>
-            <Button variant="default" onClick={onContinue}>
+            <Button
+              variant="default"
+              onClick={onContinue}
+              disabled={audioCheck.status === "checking" || audioCheck.status === "no_audio"}
+            >
               <ArrowRight className="w-4 h-4" />
               Continue
             </Button>

src/ui/src/services/ipc-client.ts

@@ -83,6 +83,9 @@ declare global {
         stop: (videoData: Uint8Array) => Promise<ScreenRecordingStopResult>;
         listSources: () => Promise<ScreenSource[]>;
         cleanupTempFile: (filePath: string) => Promise<void>;
+        hasAudio: (
+          filePath: string,
+        ) => Promise<{ success: boolean; hasAudio?: boolean; error?: string }>;
         showControlBar: (cameraDeviceId?: string) => Promise<{ success: boolean }>;
         hideControlBar: () => Promise<{ success: boolean }>;
         stopFromControlBar: () => Promise<{ success: boolean }>;