add vad and sr to streaming

app.py

@@ -21,7 +21,7 @@ from offline_pipeline import (
     load_local_file,
     run_offline_pipeline_streaming,
 )
-from utils import spec_image
+from utils import spec_image, render_vad_led
 from clean_up import purge_tmp_directory, cleanup_previous_run
 
 # Active light HTML: whole container is the light (gray = warming up, red = ready)
@@ -75,7 +75,7 @@ def process_with_live_transcript(
     noisy_spec_path = f"{APP_TMP_DIR}/{sample_stem}_noisy_spectrogram.png"
     if input_array is not None:
         try:
-            spec_image(input_array).save(noisy_spec_path)
+            spec_image(input_array, sr = current_sample_rate).save(noisy_spec_path)
         except Exception:
             noisy_spec_path = None
     else:
@@ -128,15 +128,15 @@ def process_with_live_transcript(
         enhanced_transcript,
         noisy_transcript_with_wer,
         enhanced_audio,
+        vad_labels,
         last_stem,
         enhanced_array,
         precomputed_noisy,
     ) = result_holder["result"]
-
     # 3) Last: reveal enhanced spectrogram (and final audio/transcripts)
     yield (
         gr.update(visible=True),
-        enhanced_audio,
+        gr.update(value=enhanced_audio, subtitles=vad_labels),
         enhanced_spec_path,   # enhanced_image: show only now
         noisy_spec_path,
         original_transcript,
@@ -186,7 +186,7 @@ with gr.Blocks() as demo:
         with gr.Tab("Stream audio in real time") as stream_tab:
             gr.Markdown(open("docs/online.md", "r", encoding="utf-8").read())
             with gr.Group(elem_classes="panel"):
-                stream_state = gr.State(None)
+                streaming_sr = gr.State(16000)  
                 on_stream_tab = gr.State(True)  # True on load: stream tab is the default first tab
                 warmup_elapsed = gr.State(0)
                 input_gain_db = gr.Slider(
@@ -204,6 +204,7 @@ with gr.Blocks() as demo:
                     with gr.Column(scale=1, min_width=120, elem_classes="active-light-column"):
                         active_light = gr.HTML(value=ACTIVE_LIGHT_GRAY)
                 with gr.Group(elem_classes="panel"):
+                    vad_led = gr.HTML(value=render_vad_led(False), label="Voice Activity")
                     with gr.Column(scale=5, min_width=320):
                         enhanced_text = gr.Textbox(
                             label="Enhanced Transcribed Text", lines=6, autoscroll=False
@@ -298,7 +299,7 @@ with gr.Blocks() as demo:
         lambda: (
             gr.update(visible=False),
             gr.update(visible=False),
-            gr.update(visible=True, interactive=True, streaming=True, sources=["microphone"]),
+            gr.update(sources=["microphone"], streaming=True, interactive= True),
             True,
             0,
             ACTIVE_LIGHT_GRAY,
@@ -309,16 +310,15 @@ with gr.Blocks() as demo:
     )
 
     upload_tab.select(
-        lambda: (
-            *stop_online_backend(),
-            False,
-            ACTIVE_LIGHT_GRAY,
-        ),
+        lambda: gr.update(streaming=False, interactive=False),
         inputs=None,
-        outputs=[stream_state, enhanced_text, raw_text, audio_stream, on_stream_tab, active_light],
+        outputs=[audio_stream],
     ).then(
-        lambda: gr.update(visible=True),
-        outputs=enhance_btn,
+        lambda: ( 
+            gr.update(visible=True),
+            *on_stop_recording(),
+        ),
+        outputs=[enhance_btn, vad_led, streaming_sr],
     )
 
     dataset_tab.select(
@@ -328,7 +328,7 @@ with gr.Blocks() as demo:
             ACTIVE_LIGHT_GRAY,
         ),
         inputs=None,
-        outputs=[stream_state, enhanced_text, raw_text, audio_stream, on_stream_tab, active_light],
+        outputs=[streaming_sr, enhanced_text, raw_text, audio_stream, on_stream_tab, active_light],
     ).then(
         lambda: gr.update(visible=True),
         outputs=enhance_btn,
@@ -343,10 +343,10 @@ with gr.Blocks() as demo:
     ).then(
         clear_ui,
         inputs=None,
-        outputs=[stream_state, enhanced_text, raw_text],
+        outputs=[enhanced_text, raw_text],
     ).then(
         set_stt_streamer,
-        inputs=stt_model,
+        inputs=[stt_model, streaming_sr],
         outputs=None,
     )
 
@@ -356,8 +356,8 @@ with gr.Blocks() as demo:
 
     audio_stream.stream(
         fn=transcribe_stream,
-        inputs=[stream_state, audio_stream, enhancement_level, input_gain_db],
-        outputs=[stream_state, enhanced_text, raw_text],
+        inputs=[streaming_sr, audio_stream, enhancement_level, input_gain_db, stt_model],
+        outputs=[streaming_sr, enhanced_text, raw_text, vad_led],
         stream_every=STREAM_EVERY,
         time_limit=60 * 2,
         concurrency_limit=1,
@@ -365,17 +365,15 @@ with gr.Blocks() as demo:
 
     audio_stream.stop_recording(
         on_stop_recording,
+        outputs=[vad_led, streaming_sr]
     )
 
     audio_stream.start_recording(
         clear_ui,
         inputs=None,
-        outputs=[stream_state, enhanced_text, raw_text],
-    ).then(
-        fn=set_stt_streamer,
-        inputs=stt_model,
-        outputs=None,
+        outputs=[enhanced_text, raw_text],
     )
+    
 
     # ------------------------------------------------------
     # OFFLINE PIPELINE EVENTS (DATASET + UPLOAD TABS)

offline_pipeline.py

@@ -3,13 +3,15 @@ from random import sample
 
 import gradio as gr
 import soundfile as sf
-from sdk import SDKWrapper
-from utils import spec_image, compute_wer, to_gradio_audio, normalize_lufs
+from sdk import SDKWrapper, SDKParams
+from utils import spec_image, compute_wer, to_gradio_audio, normalize_lufs, get_vad_labels
 from hf_dataset_utils import get_audio, get_transcript
 from constants import APP_TMP_DIR, STREAMER_CLASSES
 import numpy as np
 
 
+SDK_OFFLINE = SDKWrapper()
+
 def _close_stt_stream(streamer) -> None:
     """Signal end-of-stream; streamer type may be Soniox (close_stream) or Deepgram (close)."""
     if hasattr(streamer, "close_stream"):
@@ -24,7 +26,7 @@ def run_offline_pipeline_streaming(
     sample_id: str,
     stt_model: str,
     progress_state: dict,
-) -> tuple[str, str, str, tuple[int, np.ndarray], str, np.ndarray, str]:
+) -> tuple[str, str, str, tuple[int, np.ndarray], list, str, np.ndarray, str]:
     """Run enhancement and both STTs in real time by processing in chunks. Transcripts stream
     via progress_state['noisy'] and progress_state['enhanced']. Enhanced audio is returned
     only at the end; the app plays it automatically when processing is complete.
@@ -32,13 +34,14 @@ def run_offline_pipeline_streaming(
     if sample is None:
         raise ValueError("No audio to enhance. Please upload a file first.")
     sample = np.asarray(sample, dtype=np.float32).flatten()
-
-    sdk = SDKWrapper()
-    sdk.init_processor(
+    sdk_params = SDKParams(
         sample_rate=sample_rate,
-        enhancement_level=float(enhancement_level) / 100.0,
+        enhancement_level=enhancement_level/100.0,
+        allow_variable_frames=False,  # streaming pipeline uses fixed frames for simplicity
+        num_channels=1,
     )
-    chunk_size = sdk.num_frames
+    SDK_OFFLINE.init_processor(sdk_params)
+    chunk_size = SDK_OFFLINE.num_frames
 
     # Sync transcript callbacks so both boxes update together
     progress_state["noisy_pending"] = ""
@@ -68,6 +71,7 @@ def run_offline_pipeline_streaming(
     streamer_enhanced = StreamerClass(sample_rate, f"{sample_id}_enhanced", on_update=on_enhanced)
 
     accumulated_enhanced: list[np.ndarray] = []
+    vad_timestamps = []
     n = len(sample)
 
     for i in range(0, n, chunk_size):
@@ -80,12 +84,17 @@ def run_offline_pipeline_streaming(
                 constant_values=0.0,
             )
         raw_2d = raw_chunk.reshape(1, -1)
-        enhanced_chunk = sdk.process_chunk(raw_2d)
+        enhanced_chunk = SDK_OFFLINE.process_chunk(raw_2d)
         enhanced_1d = np.asarray(enhanced_chunk).flatten()
         streamer_noisy.process_chunk(raw_chunk)
         streamer_enhanced.process_chunk(enhanced_1d)
         accumulated_enhanced.append(enhanced_1d)
-
+        
+        if SDK_OFFLINE.vad_context.is_speech_detected():
+            start_in_sec = i/ sample_rate
+            end_in_sec = (i + chunk_size) / sample_rate
+            vad_timestamps.append([start_in_sec, end_in_sec])
+            
     _close_stt_stream(streamer_noisy)
     _close_stt_stream(streamer_enhanced)
     streamer_noisy.finished_event.wait()
@@ -100,7 +109,7 @@ def run_offline_pipeline_streaming(
     gradio_enhanced_audio = to_gradio_audio(enhanced_array, sample_rate)
 
     enhanced_spec_path = f"{APP_TMP_DIR}/{sample_id}_enhanced_spectrogram.png"
-    spec_image(enhanced_array).save(enhanced_spec_path)
+    spec_image(enhanced_array, sr = sample_rate).save(enhanced_spec_path)
     progress_state["enhanced_spec_path"] = enhanced_spec_path
 
     precomputed_noisy = noisy_transcript
@@ -113,11 +122,13 @@ def run_offline_pipeline_streaming(
     except Exception:
         pass
 
+    vad_labels = get_vad_labels(vad_timestamps, length=len(sample)/sample_rate)
     return (
         enhanced_spec_path,
         enhanced_transcript,
         noisy_transcript,
         gradio_enhanced_audio,
+        vad_labels,
         sample_id,
         enhanced_array,
         precomputed_noisy,
@@ -126,9 +137,9 @@ def run_offline_pipeline_streaming(
 def load_local_file(
     sample_path: str,
     normalize: bool = True,
-    ) -> tuple[np.ndarray | None, str, tuple | None, int]:
+    ) -> tuple[np.ndarray | None, str, tuple | None, int | None]:
     if not sample_path or not os.path.exists(sample_path):
-        return None, "", None
+        return None, "", None, None
     if os.path.getsize(sample_path) > 5 * 1024 * 1024:
         gr.Warning("File size exceeds 5 MB limit. Please upload a smaller file.")
         raise ValueError("Uploaded file exceeds the 5 MB size limit.")

sdk.py

@@ -1,3 +1,5 @@
+from logging import config
+
 import numpy as np
 from dotenv import load_dotenv
 import aic_sdk as aic
@@ -8,6 +10,24 @@ from constants import MODEL_ID
 load_dotenv()
 
 
+class SDKParams:
+    def __init__(
+        self,
+        sample_rate: int = 16000,
+        enhancement_level: float = 1.0,
+        allow_variable_frames: bool = False,
+        num_channels: int = 1,
+        sync: bool = True,
+        num_frames: int | None = None,
+        
+    ):
+        self.sample_rate = sample_rate
+        self.enhancement_level = enhancement_level
+        self.allow_variable_frames = allow_variable_frames
+        self.num_channels = num_channels
+        self.sync = sync
+        self.num_frames = num_frames  # to be set after processor init
+
 class SDKWrapper:
     def __init__(self, model_id: str = MODEL_ID, models_dir: str = "./models"):
         if os.getenv("AIC_SDK_KEY") is None:
@@ -16,25 +36,25 @@ class SDKWrapper:
         model_path = aic.Model.download(model_id, models_dir)
         self.model = aic.Model.from_file(model_path)
 
-
-    def init_processor(self, sample_rate: int, enhancement_level: float, allow_variable_frames: bool = False, num_frames: int | None = None,num_channels: int = 1, sync: bool = True):
-        self.processor_sample_rate = sample_rate
-        processor_optimal_frames = self.model.get_optimal_num_frames(sample_rate)
-        self.num_frames = num_frames if num_frames else processor_optimal_frames
-        config = aic.ProcessorConfig(
-            sample_rate=sample_rate,
-            num_channels=num_channels,
+    def init_processor(self, sdk_params: SDKParams):
+        optimal_frames = self.model.get_optimal_num_frames(sdk_params.sample_rate)
+        self.num_frames = sdk_params.num_frames if sdk_params.num_frames else optimal_frames
+        self.sample_rate = sdk_params.sample_rate
+        aic_config = aic.ProcessorConfig(
+            sample_rate=sdk_params.sample_rate,
+            num_channels=sdk_params.num_channels,
             num_frames=self.num_frames,
-            allow_variable_frames=allow_variable_frames,
+            allow_variable_frames=sdk_params.allow_variable_frames,
         )
-        if sync:
-            processor = aic.Processor(self.model, self.sdk_key, config)
+        if sdk_params.sync:
+            self.processor = aic.Processor(self.model, self.sdk_key, aic_config)
         else:
-            processor = aic.ProcessorAsync(self.model, self.sdk_key, config)
-        processor.get_processor_context().set_parameter(
-            aic.ProcessorParameter.EnhancementLevel, float(enhancement_level)
+            self.processor = aic.ProcessorAsync(self.model, self.sdk_key, aic_config)
+        self.processor.get_processor_context().set_parameter(
+            aic.ProcessorParameter.EnhancementLevel, float(sdk_params.enhancement_level)
         )
-        self.processor = processor
+        self.enhancement_level = sdk_params.enhancement_level
+        self.vad_context = self.processor.get_vad_context()
 
     def change_enhancement_level(self, enhancement_level: float):
         if not hasattr(self, "processor"):
@@ -42,6 +62,7 @@ class SDKWrapper:
         self.processor.get_processor_context().set_parameter(
             aic.ProcessorParameter.EnhancementLevel, float(enhancement_level)
         )
+        self.enhancement_level = enhancement_level
     
     def _check_shape(self, audio: np.ndarray) -> np.ndarray:
         if len(audio.shape) == 1:
@@ -50,15 +71,17 @@ class SDKWrapper:
             raise ValueError("Expected audio with shape (n, frames)")
         return audio
     
-    def process_sync(
+    def process_with_vad(
         self,
         audio: np.ndarray,
-    ) -> np.ndarray:
+    ) -> tuple[np.ndarray, bool]:
         """
             audio_array: 2D NumPy array with shape (num_channels, samples) containing audio data to be enhanced
         """
         audio = self._check_shape(audio)
         out = np.zeros_like(audio)
+        vad_per_sample = np.zeros_like(audio, dtype=bool)
+        vad_overall = False
         chunk_size = self.num_frames
         n = audio.shape[1]
         for i in range(0, n, chunk_size):
@@ -72,7 +95,11 @@ class SDKWrapper:
                 break
             enhanced = self.processor.process(chunk)
             out[:, i : i + chunk_size] = enhanced[:, :chunk_size]
-        return out
+            if self.vad_context.is_speech_detected():
+                vad_per_sample[:, i : i + chunk_size] = True
+        if vad_per_sample.mean() > 0.5:
+            vad_overall = True
+        return out, vad_overall
     
     def process_chunk(self, audio: np.ndarray) -> np.ndarray:
         audio = self._check_shape(audio)

stream_pipeline.py

@@ -1,10 +1,12 @@
+from datasets import streaming
 import gradio as gr
+from httpx import stream
 import numpy as np
-import soxr
-from constants import DEFAULT_SR, STREAMER_CLASSES
+from constants import STREAMER_CLASSES
 from stt_streamers import DeepgramStreamer
-from sdk import SDKWrapper
-from dataclasses import dataclass
+from sdk import SDKWrapper, SDKParams
+from typing import Any
+from utils import render_vad_led
 
 # ----------------------------
 # Global transcript store (UI pulls from this)
@@ -28,13 +30,8 @@ def get_live_transcripts() -> tuple[str, str]:
     return _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
 
 
-SDK = SDKWrapper()
-SDK.init_processor(
-    sample_rate=DEFAULT_SR,
-    enhancement_level=1.0,
-    allow_variable_frames=True,  # streaming chunks are variable-sized
-    num_channels=1,
-)
+SDK_STREAMING = SDKWrapper()
+
 
 # Created on first start_recording (lazy) to avoid Soniox "No audio received" timeout at app load
 Streamer_enhanced = None
@@ -43,25 +40,16 @@ _streamer_generation = 0
 _last_stop_generation = 1  # so first stop doesn't skip (1 > 1 is False)
 
 
-@dataclass
-class EnhanceSession:
-    pending: np.ndarray        # 1D float32 @ processor sample rate
-    sr: int
-    num_frames: int
-@dataclass
-class StreamSession:
-    # nur was du wirklich brauchst
-    resampler: soxr.ResampleStream | None
-    sr_in: int | None
-    tail_16k: np.ndarray  # ring buffer (z.B. letzte 10s)
-    tail_max: int         # max samples
-
-def _get_or_init_session(session: StreamSession | None, sr_in: int) -> StreamSession:
-    if session is None or session.sr_in != sr_in:
-        # ResampleStream ist für real-time processing gedacht citeturn8view0
-        resampler = None if sr_in == DEFAULT_SR else soxr.ResampleStream(sr_in, DEFAULT_SR, num_channels=1, dtype="float32")
-        return StreamSession(resampler=resampler, sr_in=sr_in, tail_16k=np.zeros((0,), dtype=np.float32), tail_max=10 * DEFAULT_SR)
-    return session
+def init_streaming_sdk(sample_rate: int, enhancement_level: float):
+    """Initialize SDK processor and STT streamers. Call on first start_recording to avoid Soniox timeout at app load."""
+    sdk_params = SDKParams(
+        sample_rate=sample_rate,
+        enhancement_level=enhancement_level,
+        allow_variable_frames=False,
+        num_channels=1,
+        sync=True, 
+    )
+    SDK_STREAMING.init_processor(sdk_params)
 
 def _to_float32_mono(y: np.ndarray) -> np.ndarray:
     # Gradio liefert int16 (oder (samples, channels)). citeturn1view4
@@ -75,57 +63,32 @@ def _to_float32_mono(y: np.ndarray) -> np.ndarray:
     return y
 
 
-def transcribe_stream(session: StreamSession | None, new_chunk, enhancement_level, input_gain_db: float = 0.0):
-    if (
-        Streamer_enhanced is None
-        or Streamer_raw is None
-        or Streamer_enhanced.ws is None
-        or Streamer_raw.ws is None
-    ):
-        return session, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
+def transcribe_stream(current_sr: int | None, new_chunk, enhancement_level, input_gain_db: float = 0.0, stt_streamer: str = "deepgram") -> tuple[int | None, str, str, Any]:
+    print("Transcribing")
     if new_chunk is None or new_chunk[1] is None:
-        return session, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
-
+        return None, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT, render_vad_led(False)  # No audio, so no VAD; return LED off
     sr, y = new_chunk
+    if current_sr != sr:
+        init_streaming_sdk(sample_rate=sr, enhancement_level=enhancement_level/100.0)
+        set_stt_streamer(stt_streamer, sr)
+        current_sr = sr
+    if SDK_STREAMING.enhancement_level != enhancement_level:
+        SDK_STREAMING.change_enhancement_level(enhancement_level/100.0)
     y = _to_float32_mono(y)
-    # Apply input gain: linear = 10^(dB/20), clip to avoid overflow
     if input_gain_db is not None and input_gain_db > 0:
         gain_linear = np.float32(10.0 ** (float(input_gain_db) / 20.0))
         y = (y * gain_linear).astype(np.float32)
         y = np.clip(y, -1.0, 1.0)
-
-    session = _get_or_init_session(session, sr)
-    SDK.change_enhancement_level(float(enhancement_level) / 100.0)
-    if session.resampler is not None:
-        y_16k = session.resampler.resample_chunk(y)
-    else:
-        y_16k = y
-
-    # Ensure 1D float32 for SDK and streamers (resample_chunk can return 0 samples or 2D)
-    y_16k = np.asarray(y_16k, dtype=np.float32).flatten()
-
-    # Ringbuffer (nicht unendlich konkatenieren)
-    if y_16k.size > 0:
-        tail = np.concatenate([session.tail_16k, y_16k])
-        if tail.size > session.tail_max:
-            tail = tail[-session.tail_max:]
-        session.tail_16k = tail
-
-    # Only send when we have samples (resample_chunk can return empty; SDK needs valid input)
-    if y_16k.size == 0:
-        return session, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
-
-    # Parallel path: send raw to STT immediately, then enhance and send enhanced.
-    # SDK requires fixed num_frames (AudioConfigMismatchError if we use process_chunk with variable size).
-    Streamer_raw.process_chunk(y_16k)
-    enhanced_chunk_16k = SDK.process_sync(y_16k)
+    y = np.asarray(y, dtype=np.float32).flatten()
+    enhanced_chunk_16k, vad_detected = SDK_STREAMING.process_with_vad(y)
     out_1d = np.asarray(enhanced_chunk_16k, dtype=np.float32).flatten()
-    # Always send something to enhanced so Soniox doesn't close with "No audio received"
-    if out_1d.size > 0:
+    if (
+        Streamer_enhanced is not None
+        and Streamer_raw is not None
+    ):
+        Streamer_raw.process_chunk(y)
         Streamer_enhanced.process_chunk(out_1d)
-    else:
-        Streamer_enhanced.process_chunk(np.zeros(160, dtype=np.float32))
-    return session, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
+    return current_sr, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT, render_vad_led(vad_detected)
 
 
 def shutdown_streamers(from_stop_recording: bool = False):
@@ -149,26 +112,26 @@ def shutdown_streamers(from_stop_recording: bool = False):
             _last_stop_generation = gen
     
 def on_stop_recording():
-    """Call from Gradio stop_recording so streamers shut down when user clicks Stop."""
-    shutdown_streamers(from_stop_recording=True)
+    shutdown_streamers()
+    return render_vad_led(False), None
 
 
 def clear_ui():
     global _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
     _ENHANCED_TRANSCRIPT = ""
     _RAW_TRANSCRIPT = ""
-    return None, _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
+    return _ENHANCED_TRANSCRIPT, _RAW_TRANSCRIPT
 
 def stop_online_backend():
     """Stop streamers and clear transcripts. Do not update the Audio component:
     toggling streaming=False then back to True can make the frontend lose the
     microphone (getUserMedia not re-called), so we leave it unchanged."""
     shutdown_streamers()
-    session, enhanced_transcript, raw_transcript = clear_ui()
-    return session, enhanced_transcript, raw_transcript, gr.update()
+    enhanced_transcript, raw_transcript = clear_ui()
+    return None, enhanced_transcript, raw_transcript, gr.update(streaming=False, interactive=False)
 
 
-def set_stt_streamer(model_name):
+def set_stt_streamer(model_name, fs_hz):
     StreamerCls = STREAMER_CLASSES.get(model_name, DeepgramStreamer)
     global Streamer_enhanced, Streamer_raw, _streamer_generation
     # Shut down current streamers first so we don't leak
@@ -176,16 +139,17 @@ def set_stt_streamer(model_name):
         shutdown_streamers()
     # Create both before assigning so transcribe_stream never sees one new and one old
     new_enhanced = StreamerCls(
-        fs_hz=DEFAULT_SR,
+        fs_hz=fs_hz,
         stream_name="enhanced",
         on_update=_set_transcript_enhanced,
     )
     new_raw = StreamerCls(
-        fs_hz=DEFAULT_SR,
+        fs_hz=fs_hz,
         stream_name="raw",
         on_update=_set_transcript_raw,
     )
     _streamer_generation += 1
     Streamer_enhanced = new_enhanced
     Streamer_raw = new_raw
+    
     

utils.py

@@ -4,10 +4,63 @@ import librosa
 from PIL import Image
 import io
 import matplotlib.pyplot as plt
-from constants import DEFAULT_SR, TARGET_LOUDNESS, TARGET_TP
-import warnings
+from constants import TARGET_LOUDNESS, TARGET_TP
 import pyloudnorm as pyln
 
+VAD_ON_HTML = """
+<div style="display:flex; align-items:center; gap:10px;">
+    <div style="
+        width:25px;
+        height:25px;
+        border-radius:9999px;
+        background:#22c55e;
+        box-shadow:0 0 16px rgba(34,197,94,0.9);
+        border:1px solid #666;
+    "></div>
+</div>
+"""
+
+VAD_OFF_HTML = """
+<div style="display:flex; align-items:center; gap:10px;">
+    <div style="
+        width:25px;
+        height:25px;
+        border-radius:9999px;
+        background:#3f3f46;
+        box-shadow:none;
+        border:1px solid #666;
+    "></div>
+</div>
+"""
+
+SUB_ON = "🟢"
+SUB_OFF = "⚫"
+
+def get_vad_labels(vad_timestamps: list[list[float]], length: float) -> list[dict]:
+    subtitles = []
+    cur = 0.0
+    for start, end in vad_timestamps:
+        if start > cur:
+            subtitles.append({
+                "text": f"Voice Detection: {SUB_OFF}",
+                "timestamp": [cur, start]
+            })
+
+        subtitles.append({
+            "text": f"Voice Detection: {SUB_ON}",
+            "timestamp": [start, end]
+        })
+
+        cur = end
+    if cur < length:
+        subtitles.append({
+            "text": f"Voice Detection: {SUB_OFF}",
+            "timestamp": [cur, length]
+        })
+    return subtitles
+
+def render_vad_led(is_speech: bool) -> str:
+    return VAD_ON_HTML if is_speech else VAD_OFF_HTML
 
 def to_gradio_audio(x: np.ndarray, sr: int) -> tuple[int, np.ndarray]:
     """Return (sample_rate, int16 mono array) for Gradio Audio. Gradio expects int16;
@@ -35,7 +88,7 @@ def to_gradio_audio(x: np.ndarray, sr: int) -> tuple[int, np.ndarray]:
 
 def spec_image(
     audio_array: np.ndarray,
-    sr: int = DEFAULT_SR,
+    sr: int,
     n_fft: int = 2048,
     hop_length: int = 512,
     n_mels: int = 128,
@@ -139,3 +192,5 @@ def normalize_lufs(x: np.ndarray, sr: int) -> np.ndarray:
     except Exception as e:
         warnings.warn(f"LUFS normalization failed, returning input unchanged: {e}")
         return x.astype("float32")
+
+