Update app.py

app.py

@@ -1,10 +1,15 @@
-"""Audio Cleanup Studio – a Gradio Space with real audio processing and private history.
+"""Audio Cleanup Studio – a Gradio Space with real audio processing and private history.
 
 Deployment secrets and storage:
 - ADMIN_ACCESS_CODE: required to unlock the administrator archive.
 - DATA_DIR: optional persistent mounted directory; uses /data automatically when available.
 - HISTORY_RETENTION_DAYS: number of days to retain private audio artifacts (default: 30; 0 disables expiry).
 - MAX_AUDIO_MINUTES: optional maximum input duration; 0 means unlimited (default: 0).
+
+Optional dependency:
+- silero-vad (add `silero-vad` to requirements.txt) enables the AI speech detector used by
+  "Auto (AI detect)" silence removal. Without it, Auto mode still works using the built-in
+  adaptive noise-floor detector.
 """
 
 from __future__ import annotations
@@ -31,6 +36,7 @@ from pathlib import Path
 from typing import Generator, Iterable
 
 import gradio as gr
+import numpy as np
 from pydub import AudioSegment, effects
 from pydub.silence import split_on_silence
 
@@ -281,7 +287,7 @@ def admin_rows(limit: int = 100) -> list[list[str]]:
         rows = connection.execute(
             """
             SELECT job_id, public_filename, operation, status, created_at,
-                   COALESCE(completed_at, '—') AS completed_at,
+                   COALESCE(completed_at, '—') AS completed_at,
                    COALESCE(processing_seconds, 0) AS processing_seconds
             FROM jobs
             ORDER BY created_ts DESC
@@ -297,7 +303,7 @@ def admin_rows(limit: int = 100) -> list[list[str]]:
             row["status"],
             row["created_at"],
             row["completed_at"],
-            f"{row['processing_seconds']:.1f}s" if row["processing_seconds"] else "—",
+            f"{row['processing_seconds']:.1f}s" if row["processing_seconds"] else "—",
         ]
         for row in rows
     ]
@@ -315,7 +321,7 @@ def admin_job_choices() -> list[tuple[str, str]]:
             """
         ).fetchall()
     return [
-        (f"{row['activity_at']} · {row['public_filename']} · {row['operation']}", row["job_id"])
+        (f"{row['activity_at']} · {row['public_filename']} · {row['operation']}", row["job_id"])
         for row in rows
     ]
 
@@ -440,6 +446,7 @@ _DEFAULT_OVERHEAD_SECONDS = {
 }
 _DEFAULT_RATE_PER_AUDIO_SECOND = {
     "Remove silence": 0.06,
+    "Remove silence::auto": 0.08,
     "Enhance audio::deepfilter": 0.5,
     "Enhance audio::fallback": 0.65,
     "Voice / BGM isolation::htdemucs-fast": 1.0,
@@ -450,7 +457,7 @@ _DEFAULT_RATE_PER_AUDIO_SECOND = {
 def estimated_seconds(operation: str, duration: float, quality: str = "", device: str = "cpu") -> float:
     """Best-available ETA: starts from a conservative default rate, then blends in
     this deployment's own measured processing rate (from performance_stats) as soon
-    as there is enough real history for that exact operation/quality/device — so the
+    as there is enough real history for that exact operation/quality/device — so the
     estimate keeps improving instead of staying a fixed guess forever."""
     overhead = _DEFAULT_OVERHEAD_SECONDS.get(operation, 15)
     default_key = f"{operation}::{quality}" if quality else operation
@@ -470,7 +477,7 @@ def estimated_seconds(operation: str, duration: float, quality: str = "", device
 
 def dynamic_remaining(elapsed: float, estimate: float) -> tuple[float, float]:
     """Keeps the on-screen ETA honest. The static formula above is only ever a
-    prediction — if the real job is taking longer than predicted, this grows the
+    prediction — if the real job is taking longer than predicted, this grows the
     working estimate instead of freezing 'remaining' at 0 while work continues."""
     if elapsed < estimate * 0.9:
         return estimate, max(0.0, estimate - elapsed)
@@ -483,8 +490,8 @@ _PERCENT_PATTERN = re.compile(r"(\d{1,3})%\|")
 
 def parse_progress_percent(line: str) -> float | None:
     """Demucs (and some DeepFilterNet builds) print a tqdm-style '45%|...' progress
-    bar to stdout/stderr. When present, this is real model progress — far more
-    accurate than a time-based guess — so we use it whenever we can detect it."""
+    bar to stdout/stderr. When present, this is real model progress — far more
+    accurate than a time-based guess — so we use it whenever we can detect it."""
     match = _PERCENT_PATTERN.search(line)
     if not match:
         return None
@@ -578,6 +585,8 @@ def ffmpeg_convert_to_mp3(source: Path, destination: Path, bitrate: str = "192k"
 
 
 def remove_silence_audio(source: Path, destination: Path, keep_silence_ms: int) -> tuple[float, float, float]:
+    """Custom mode: split on silence using an adaptive threshold and keep a fixed
+    amount of silence (keep_silence_ms) around every chunk."""
     sound = AudioSegment.from_file(source)
     before = len(sound) / 1000.0
     if sound.dBFS == float("-inf"):
@@ -602,6 +611,215 @@ def remove_silence_audio(source: Path, destination: Path, keep_silence_ms: int)
     return before, after, threshold
 
 
+# -----------------------------------------------------------------------------
+# Auto silence removal (AI speech detector + adaptive noise-floor detector)
+# -----------------------------------------------------------------------------
+# style -> (min_silence_ms, pad_ms)
+#   min_silence_ms: pauses shorter than this are left untouched (natural commas / breathing)
+#   pad_ms:         silence kept on each side of every sound segment, so word edges never get clipped
+AUTO_STYLES: dict[str, tuple[int, int]] = {
+    "Natural": (450, 150),
+    "Balanced": (250, 90),
+    "Tight": (150, 40),
+}
+AUTO_FRAME_MS = 10
+AUTO_ANALYSIS_RATE = 16000
+AUTO_FADE_MS = 8
+
+_VAD_LOCK = threading.Lock()
+_VAD_MODEL = None
+_VAD_UNAVAILABLE = False
+
+
+def load_vad_model():
+    """Load Silero VAD once. Returns None when the package/model is unavailable."""
+    global _VAD_MODEL, _VAD_UNAVAILABLE
+    if _VAD_MODEL is not None:
+        return _VAD_MODEL
+    if _VAD_UNAVAILABLE:
+        return None
+    with _VAD_LOCK:
+        if _VAD_MODEL is None and not _VAD_UNAVAILABLE:
+            try:
+                from silero_vad import load_silero_vad
+                _VAD_MODEL = load_silero_vad()
+            except Exception:
+                _VAD_UNAVAILABLE = True
+    return _VAD_MODEL
+
+
+def vad_speech_mask(samples: np.ndarray, n_frames: int) -> np.ndarray | None:
+    """Run Silero VAD and return a per-frame boolean mask (True = speech), or None if
+    the AI detector is unavailable or fails for any reason."""
+    model = load_vad_model()
+    if model is None:
+        return None
+    try:
+        import torch
+        from silero_vad import get_speech_timestamps
+
+        with torch.no_grad():
+            stamps = get_speech_timestamps(
+                torch.from_numpy(samples),
+                model,
+                sampling_rate=AUTO_ANALYSIS_RATE,
+                threshold=0.4,  # slightly more sensitive than default so soft speech is never cut
+                min_speech_duration_ms=80,
+                min_silence_duration_ms=80,
+                speech_pad_ms=40,
+            )
+    except Exception:
+        return None
+    samples_per_frame = AUTO_ANALYSIS_RATE * AUTO_FRAME_MS // 1000
+    mask = np.zeros(n_frames, dtype=bool)
+    for stamp in stamps:
+        start = int(stamp["start"]) // samples_per_frame
+        end = -(-int(stamp["end"]) // samples_per_frame)  # ceil
+        mask[start:end] = True
+    return mask
+
+
+def _run_bounds(mask: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Start (inclusive) and end (exclusive) indices of every run of True values."""
+    edges = np.diff(np.concatenate(([0], mask.astype(np.int8), [0])))
+    return np.flatnonzero(edges == 1), np.flatnonzero(edges == -1)
+
+
+def _otsu_threshold(values: np.ndarray, low: float = -120.0, high: float = 0.0, bins: int = 240) -> float:
+    """Otsu's method on a dB histogram: finds the valley between the 'quiet' and 'loud' groups."""
+    hist, edges = np.histogram(np.clip(values, low, high), bins=bins, range=(low, high))
+    hist = hist.astype(np.float64)
+    total = hist.sum()
+    if total <= 0:
+        return float(np.median(values))
+    centers = (edges[:-1] + edges[1:]) / 2.0
+    weight_low = np.cumsum(hist)
+    weight_high = total - weight_low
+    sum_low = np.cumsum(hist * centers)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        mean_low = sum_low / weight_low
+        mean_high = (sum_low[-1] - sum_low) / weight_high
+        between = weight_low * weight_high * (mean_low - mean_high) ** 2
+    between = np.nan_to_num(between)
+    return float(centers[int(np.argmax(between))])
+
+
+def energy_activity_mask(samples: np.ndarray) -> tuple[np.ndarray, float | None]:
+    """Noise-floor-aware activity detector on 10 ms frames.
+
+    The threshold is learned from the clip itself (so it adapts to quiet or loud
+    recordings and to room noise) and hysteresis keeps soft word endings attached
+    to the word. Returns (active_mask, threshold_db); threshold_db is None when the
+    clip has no clear gap between silence and sound (everything stays active)."""
+    frame_len = AUTO_ANALYSIS_RATE * AUTO_FRAME_MS // 1000
+    padding = (-len(samples)) % frame_len
+    if padding:
+        samples = np.pad(samples, (0, padding))
+    power = np.mean(np.square(samples.reshape(-1, frame_len), dtype=np.float32), axis=1)
+    power = np.convolve(power, np.ones(3, dtype=np.float32) / 3.0, mode="same")
+    db = 10.0 * np.log10(power + 1e-12)
+
+    low_ref = float(np.percentile(db, 5))
+    high_ref = float(np.percentile(db, 95))
+    if high_ref - low_ref < 10.0:
+        return np.ones(len(db), dtype=bool), None
+
+    otsu = _otsu_threshold(db)
+    quiet = db[db <= otsu]
+    noise_ref = float(np.percentile(quiet, 90)) if quiet.size else low_ref
+    threshold = min(otsu, noise_ref + 3.0)      # just above the room-noise ceiling, never above the valley
+    threshold = max(threshold, -65.0)            # below -65 dBFS is inaudible in practice
+    threshold = min(threshold, high_ref - 10.0)  # always stay well under real content
+    seed_threshold = threshold + 5.0
+
+    starts, ends = _run_bounds(db > threshold)
+    active = np.zeros(len(db), dtype=bool)
+    min_frames = max(1, 40 // AUTO_FRAME_MS)     # ignore clicks/pops shorter than 40 ms
+    for start, end in zip(starts, ends):
+        if end - start >= min_frames and db[start:end].max() >= seed_threshold:
+            active[start:end] = True
+    return active, threshold
+
+
+def detect_active_segments(sound: AudioSegment) -> tuple[list[tuple[int, int]], dict]:
+    """Return [(start_ms, end_ms), ...] of every stretch that contains real sound."""
+    mono = sound.set_channels(1).set_frame_rate(AUTO_ANALYSIS_RATE).set_sample_width(2)
+    samples = np.frombuffer(mono.raw_data, dtype=np.int16).astype(np.float32) / 32768.0
+
+    energy_mask, threshold = energy_activity_mask(samples)
+    vad_mask = vad_speech_mask(samples, len(energy_mask))
+    if vad_mask is not None:
+        engine = "Silero VAD (AI) + adaptive noise-floor detector"
+        if threshold is None:
+            # No clear energy gap (steady noise / music bed): trust the AI only if it really found speech.
+            active = vad_mask if vad_mask.mean() >= 0.02 else energy_mask
+        else:
+            # Union = never cut something that either detector considers real sound.
+            active = energy_mask | vad_mask
+    else:
+        engine = "Adaptive noise-floor detector (install silero-vad for AI mode)"
+        active = energy_mask
+
+    starts, ends = _run_bounds(active)
+    segments = [(int(s) * AUTO_FRAME_MS, int(e) * AUTO_FRAME_MS) for s, e in zip(starts, ends)]
+    return segments, {"engine": engine, "threshold": threshold}
+
+
+def build_keep_ranges(
+    segments: list[tuple[int, int]], total_ms: int, min_silence_ms: int, pad_ms: int
+) -> list[tuple[int, int]]:
+    """Merge segments separated by short pauses, then add edge padding to every kept range."""
+    merged: list[list[int]] = []
+    for start, end in segments:
+        if merged and start - merged[-1][1] < min_silence_ms:
+            merged[-1][1] = end
+        else:
+            merged.append([start, end])
+    keep: list[list[int]] = []
+    for start, end in merged:
+        start, end = max(0, start - pad_ms), min(total_ms, end + pad_ms)
+        if keep and start <= keep[-1][1]:
+            keep[-1][1] = max(keep[-1][1], end)
+        else:
+            keep.append([start, end])
+    return [(start, end) for start, end in keep]
+
+
+def auto_remove_silence_audio(source: Path, destination: Path, style: str) -> dict:
+    """Auto mode: detect sound automatically, drop the silent gaps, and join the kept
+    parts with tiny fades so there are no clicks. Returns a small stats dict."""
+    sound = AudioSegment.from_file(source)
+    total_ms = len(sound)
+    if total_ms <= 0 or sound.dBFS == float("-inf"):
+        raise ValueError("The uploaded file is completely silent.")
+
+    min_silence_ms, pad_ms = AUTO_STYLES.get(style, AUTO_STYLES["Balanced"])
+    segments, info = detect_active_segments(sound)
+    if not segments:
+        raise ValueError("Auto detection could not find any non-silent audio.")
+    keep = build_keep_ranges(segments, total_ms, min_silence_ms, pad_ms)
+
+    pieces: list[bytes] = []
+    for index, (start, end) in enumerate(keep):
+        chunk = sound[start:end]
+        fade = min(AUTO_FADE_MS, len(chunk) // 2)
+        if fade > 0:
+            if index > 0:
+                chunk = chunk.fade_in(fade)
+            if index < len(keep) - 1:
+                chunk = chunk.fade_out(fade)
+        pieces.append(chunk.raw_data)
+    combined = sound._spawn(b"".join(pieces))
+    combined.export(destination, format="wav")
+    return {
+        "before": total_ms / 1000.0,
+        "after": len(combined) / 1000.0,
+        "threshold": info["threshold"],
+        "engine": info["engine"],
+        "cuts": max(0, len(keep) - 1),
+    }
+
+
 def spectral_denoise_fallback(source: Path, destination: Path, strength: str) -> None:
     """A real, audible fallback when DeepFilterNet cannot initialise."""
     import numpy as np
@@ -661,10 +879,10 @@ def gpu_status() -> str:
         import torch
         if torch.cuda.is_available():
             name = torch.cuda.get_device_name(0)
-            return f"GPU: CUDA enabled · {name}"
+            return f"GPU: CUDA enabled · {name}"
     except Exception:
         pass
-    return "GPU: unavailable · CPU fallback"
+    return "GPU: unavailable · CPU fallback"
 
 def subprocess_progress(
     command: list[str],
@@ -675,7 +893,7 @@ def subprocess_progress(
 ) -> Generator[tuple[str, float, float], None, None]:
     """Yield (latest_log_line, remaining_seconds, progress_fraction) while a model
     subprocess runs. When the tool prints its own tqdm-style '45%|...' progress,
-    that real progress drives both the fraction and the ETA math — otherwise this
+    that real progress drives both the fraction and the ETA math — otherwise this
     falls back to the honest, self-correcting time estimate."""
     process = subprocess.Popen(
         command,
@@ -709,7 +927,7 @@ def subprocess_progress(
                 break
         elapsed = time.monotonic() - started
         if elapsed - last_yield >= 1.0:
-            latest = output_lines[-1] if output_lines else f"{label} is running…"
+            latest = output_lines[-1] if output_lines else f"{label} is running…"
             detected = parse_progress_percent(latest)
             if detected is not None:
                 real_progress = detected
@@ -803,17 +1021,22 @@ def run_with_heartbeat(work, estimate: float, progress, status_callback, *, star
     return result.get("value")
 
 # -----------------------------------------------------------------------------
-# Gradio processing flows – generators make logs and ETA visible during work.
+# Gradio processing flows – generators make logs and ETA visible during work.
 # -----------------------------------------------------------------------------
 def process_remove_silence(
     audio_file: str | None,
     keep_silence_seconds: float,
+    silence_mode: str = "Custom value",
+    auto_style: str = "Balanced",
     progress: gr.Progress = gr.Progress(),
 ):
     logs: TimedLogList = TimedLogList()
     started = time.monotonic()
     job_id = uuid.uuid4().hex
     stats, table = recent_public_history()
+    auto_mode = str(silence_mode).startswith("Auto")
+    operation_name = "Remove silence (Auto)" if auto_mode else "Remove silence"
+    quality_key = "auto" if auto_mode else ""
 
     def state(status: str, eta: str, audio=gr.skip(), file=gr.skip(), duration=gr.skip(), processed=gr.skip()):
         return audio, file, duration, processed, status, "\n".join(logs), eta, stats, table
@@ -822,23 +1045,35 @@ def process_remove_silence(
         if not audio_file:
             raise ValueError("Upload an audio file before processing.")
         logs.append("[1/4] Validating uploaded file")
-        yield state("Validating upload…", "ETA: calculating…")
+        yield state("Validating upload…", "ETA: calculating…")
 
         job_dir = make_job_directory(job_id)
         original = copy_input_to_job(audio_file, job_dir)
         duration = audio_duration(original)
         validate_duration(duration)
-        record_job_started(job_id, safe_filename(Path(audio_file).name), "Remove silence", duration)
-        estimate = estimated_seconds("Remove silence", duration, "", "cpu")
-        logs.append(f"[2/4] Duration: {duration:.2f}s · adaptive silence detection enabled")
+        record_job_started(job_id, safe_filename(Path(audio_file).name), operation_name, duration)
+        estimate = estimated_seconds("Remove silence", duration, quality_key, "cpu")
+        if auto_mode:
+            logs.append(f"[2/4] Duration: {duration:.2f}s · Auto mode ({auto_style}) · automatic silence detection")
+        else:
+            logs.append(f"[2/4] Duration: {duration:.2f}s · adaptive silence detection enabled")
         progress(0.2, desc="Detecting silence")
-        yield state("Detecting silent sections…", f"Estimated remaining: {format_seconds(estimate)}")
+        yield state("Detecting silent sections…", f"Estimated remaining: {format_seconds(estimate)}")
 
         output = job_dir / f"{original.stem}_silence_removed.wav"
         mp3_output = job_dir / f"{original.stem}_silence_removed.mp3"
-        silence_result = None
+        keep_ms = int(max(0.0, float(keep_silence_seconds or 0)) * 1000)
+        result_box: dict = {}
+
+        def work() -> None:
+            if auto_mode:
+                result_box.update(auto_remove_silence_audio(original, output, auto_style))
+            else:
+                before_s, after_s, threshold_db = remove_silence_audio(original, output, keep_ms)
+                result_box.update(before=before_s, after=after_s, threshold=threshold_db)
+
         heartbeat = run_with_heartbeat(
-            lambda: remove_silence_audio(original, output, int(max(0, float(keep_silence_seconds)) * 1000)),
+            work,
             estimate,
             progress,
             lambda pct, eta: "Detecting silent sections",
@@ -846,33 +1081,41 @@ def process_remove_silence(
             end_progress=0.72,
         )
         for pct, eta in heartbeat:
-            yield state("Detecting silent sections…", f"Estimated remaining: {eta}")
-        # The generator return value is not directly exposed by a for-loop, so run the operation
-        # once more is not acceptable; use the worker-result bridge below.
-        # (The helper stores its result in the output file; derive exact duration values afterward.)
-        before = duration
-        after = audio_duration(output)
-        threshold = max(-55.0, min(-25.0, AudioSegment.from_file(original).dBFS - 18.0))
-        logs.append(f"[3/4] Removed silence using {threshold:.1f} dB threshold")
+            yield state("Detecting silent sections…", f"Estimated remaining: {eta}")
+
+        before = result_box["before"]
+        after = result_box["after"]
+        if auto_mode:
+            threshold_db = result_box.get("threshold")
+            threshold_text = f"{threshold_db:.1f} dB" if threshold_db is not None else "no clear noise gap (kept everything)"
+            logs.append(f"[3/4] {result_box['engine']} · threshold {threshold_text} · {result_box['cuts']} cut(s)")
+        else:
+            logs.append(f"[3/4] Removed silence using {result_box['threshold']:.1f} dB threshold")
         progress(0.75, desc="Saving result")
-        yield state("Saving result…", "Estimated remaining: a few seconds")
+        yield state("Saving result…", "Estimated remaining: a few seconds")
 
         logs.append("[3.5/4] Encoding MP3 on backend with FFmpeg")
         ffmpeg_convert_to_mp3(output, mp3_output, "192k")
         archive_dir, archived_files = private_archive(job_id, original, [output, mp3_output])
         elapsed = time.monotonic() - started
-        record_job_finished(job_id, "Completed", elapsed, f"Silence removed: {before:.2f}s → {after:.2f}s", archive_dir, archived_files)
-        record_performance_sample("Remove silence", "", "cpu", before, elapsed)
+        mode_label = f"Auto ({auto_style})" if auto_mode else "Custom value"
+        record_job_finished(job_id, "Completed", elapsed, f"Silence removed [{mode_label}]: {before:.2f}s → {after:.2f}s", archive_dir, archived_files)
+        record_performance_sample("Remove silence", quality_key, "cpu", before, elapsed)
         stats, table = recent_public_history()
-        logs.append(f"[4/4] Completed in {elapsed:.1f}s · private copy saved for admin")
+        logs.append(f"[4/4] Completed in {elapsed:.1f}s · private copy saved for admin")
         progress(1.0, desc="Completed")
-        text = f"Original: {before:.3f} seconds\nProcessed: {after:.3f} seconds\nRemoved: {max(0, before - after):.3f} seconds"
-        yield state("Completed — silence removed.", "ETA: complete", str(output), str(mp3_output), text, str(mp3_output))
+        text = (
+            f"Mode: {mode_label}\n"
+            f"Original: {before:.3f} seconds\n"
+            f"Processed: {after:.3f} seconds\n"
+            f"Removed: {max(0, before - after):.3f} seconds"
+        )
+        yield state("Completed — silence removed.", "ETA: complete", str(output), str(mp3_output), text, str(mp3_output))
     except Exception as exc:
         elapsed = time.monotonic() - started
         if audio_file:
             try:
-                record_job_started(job_id, safe_filename(Path(audio_file).name), "Remove silence", 0)
+                record_job_started(job_id, safe_filename(Path(audio_file).name), operation_name, 0)
             except sqlite3.IntegrityError:
                 pass
             record_job_finished(job_id, "Failed", elapsed, str(exc))
@@ -899,7 +1142,7 @@ def process_enhance_audio(
         if not audio_file:
             raise ValueError("Upload an audio file before using Enhance Audio.")
         logs.append("[1/4] Preparing uploaded audio for real noise suppression")
-        yield state("Preparing enhancement…", "ETA: calculating…")
+        yield state("Preparing enhancement…", "ETA: calculating…")
         job_dir = make_job_directory(job_id)
         original = copy_input_to_job(audio_file, job_dir)
         duration = audio_duration(original)
@@ -914,7 +1157,7 @@ def process_enhance_audio(
         ffmpeg_convert_to_wav(original, wav_input, sample_rate=48000, mono=True)
         logs.append("[2/4] Converted to 48 kHz mono for speech-noise processing")
         progress(0.15, desc="Preparing audio")
-        yield state("Running AI noise suppression…", f"Estimated remaining: {format_seconds(estimate)}")
+        yield state("Running AI noise suppression…", f"Estimated remaining: {format_seconds(estimate)}")
 
         output_dir = job_dir / "deepfilter_output"
         output_dir.mkdir(exist_ok=True)
@@ -929,7 +1172,7 @@ def process_enhance_audio(
                 for line, remaining, fraction in subprocess_progress(command, estimate, "DeepFilterNet", job_dir):
                     logs.append(line)
                     progress(min(0.9, 0.2 + 0.65 * fraction), desc="Suppressing noise")
-                    yield state("AI noise suppression is running…", f"Estimated remaining: {format_seconds(remaining)}")
+                    yield state("AI noise suppression is running…", f"Estimated remaining: {format_seconds(remaining)}")
                 model_output = locate_enhanced_file(output_dir, wav_input)
                 if not model_output:
                     raise RuntimeError("DeepFilterNet completed but did not produce an audio file.")
@@ -942,7 +1185,7 @@ def process_enhance_audio(
 
         if used_fallback:
             logs.append("[3/4] Using spectral denoise fallback")
-            yield state("Applying spectral noise suppression…", f"Estimated remaining: {format_seconds(estimate)}")
+            yield state("Applying spectral noise suppression…", f"Estimated remaining: {format_seconds(estimate)}")
             heartbeat = run_with_heartbeat(
                 lambda: spectral_denoise_fallback(original, output, strength),
                 estimate,
@@ -952,7 +1195,7 @@ def process_enhance_audio(
                 end_progress=0.88,
             )
             for pct, eta in heartbeat:
-                yield state("Applying spectral noise suppression…", f"Estimated remaining: {eta}")
+                yield state("Applying spectral noise suppression…", f"Estimated remaining: {eta}")
             logs.append("Spectral denoise and 80 Hz rumble filter completed (CPU fallback path).")
 
         # Keep output level consistent even if the denoiser's output is quiet.
@@ -966,9 +1209,9 @@ def process_enhance_audio(
         final_quality = "fallback" if used_fallback else "deepfilter"
         record_performance_sample("Enhance audio", final_quality, "cpu" if used_fallback else device, duration, elapsed)
         stats, table = recent_public_history()
-        logs.append(f"[4/4] Completed in {elapsed:.1f}s · enhanced WAV is ready")
+        logs.append(f"[4/4] Completed in {elapsed:.1f}s · enhanced WAV is ready")
         progress(1.0, desc="Completed")
-        yield state("Completed — background noise reduced and audio normalized.", "ETA: complete", str(output), str(mp3_output))
+        yield state("Completed — background noise reduced and audio normalized.", "ETA: complete", str(output), str(mp3_output))
     except Exception as exc:
         elapsed = time.monotonic() - started
         if audio_file:
@@ -1005,7 +1248,7 @@ def process_voice_separation(
         model = "htdemucs"
         fast_mode = model_choice != "High quality"
         logs.append("[1/4] Validating uploaded audio for stem separation")
-        yield state("Validating upload…", "ETA: calculating…")
+        yield state("Validating upload…", "ETA: calculating…")
         job_dir = make_job_directory(job_id)
         original = copy_input_to_job(audio_file, job_dir)
         duration = audio_duration(original)
@@ -1018,7 +1261,7 @@ def process_voice_separation(
         logs.append("[2/4] Preparing local HTDemucs model cache")
         logs.append("Using Hugging Face mirror instead of dl.fbaipublicfiles.com")
         progress(0.06, desc="Preparing separation model")
-        yield state("Preparing separation model…", "ETA: model setup")
+        yield state("Preparing separation model…", "ETA: model setup")
 
         download_state = {"downloaded": 0, "total": None, "done": False, "error": None}
 
@@ -1037,10 +1280,10 @@ def process_voice_separation(
             downloaded, total = download_state["downloaded"], download_state["total"]
             if total:
                 pct = downloaded / total
-                logs.append(f"Downloading separation model… {pct * 100:.0f}% ({downloaded // (1024 * 1024)}MB / {total // (1024 * 1024)}MB)")
-                yield state("Downloading separation model…", f"Model download: {pct * 100:.0f}%")
+                logs.append(f"Downloading separation model… {pct * 100:.0f}% ({downloaded // (1024 * 1024)}MB / {total // (1024 * 1024)}MB)")
+                yield state("Downloading separation model…", f"Model download: {pct * 100:.0f}%")
             else:
-                yield state("Downloading separation model…", "ETA: model setup")
+                yield state("Downloading separation model…", "ETA: model setup")
             time.sleep(0.5)
         if download_state["error"] is not None:
             raise RuntimeError(
@@ -1049,9 +1292,9 @@ def process_voice_separation(
             ) from download_state["error"]
         model_repo = DEMUCS_MODEL_DIR
 
-        logs.append(f"[3/4] {device.upper()} separation · shifts={0 if fast_mode else 1} · overlap={0.10 if fast_mode else 0.25} · segment=7s")
+        logs.append(f"[3/4] {device.upper()} separation · shifts={0 if fast_mode else 1} · overlap={0.10 if fast_mode else 0.25} · segment=7s")
         progress(0.10, desc=f"Starting {device.upper()} separation")
-        yield state("Separating voice and BGM…", f"Estimated remaining: {format_seconds(estimate)}")
+        yield state("Separating voice and BGM…", f"Estimated remaining: {format_seconds(estimate)}")
 
         output_dir = job_dir / "separated"
         command = [
@@ -1070,7 +1313,7 @@ def process_voice_separation(
         for line, remaining, fraction in subprocess_progress(command, estimate, "Demucs", job_dir, env=demucs_env):
             logs.append(line)
             progress(min(0.92, 0.1 + 0.78 * fraction), desc="Separating stems")
-            yield state("Separating voice and BGM…", f"Estimated remaining: {format_seconds(remaining)}")
+            yield state("Separating voice and BGM…", f"Estimated remaining: {format_seconds(remaining)}")
 
         vocals = locate_stem(output_dir, "vocals")
         bgm = locate_stem(output_dir, "no_vocals")
@@ -1086,9 +1329,9 @@ def process_voice_separation(
         record_job_finished(job_id, "Completed", elapsed, f"Demucs {model}: vocals and BGM isolated", archive_dir, archived_files)
         record_performance_sample("Voice / BGM isolation", model_quality, device, duration, elapsed)
         stats, table = recent_public_history()
-        logs.append(f"[4/4] Completed in {elapsed:.1f}s · both stems are ready")
+        logs.append(f"[4/4] Completed in {elapsed:.1f}s · both stems are ready")
         progress(1.0, desc="Completed")
-        yield state("Completed — voice and BGM are available separately.", "ETA: complete", str(vocals), str(bgm), str(vocals_mp3), str(bgm_mp3))
+        yield state("Completed — voice and BGM are available separately.", "ETA: complete", str(vocals), str(bgm), str(vocals_mp3), str(bgm_mp3))
     except Exception as exc:
         elapsed = time.monotonic() - started
         if audio_file:
@@ -1115,6 +1358,12 @@ CSS = """
 """
 
 
+def toggle_silence_controls(mode: str):
+    """Custom mode shows the 'keep silence' number; Auto mode shows the cut-style picker."""
+    auto = str(mode).startswith("Auto")
+    return gr.update(visible=not auto), gr.update(visible=auto)
+
+
 def ui() -> gr.Blocks:
     stats, table = recent_public_history()
     with gr.Blocks() as demo:
@@ -1123,14 +1372,14 @@ def ui() -> gr.Blocks:
         admin_session_state = gr.State(value=None)
 
         gr.HTML(
-            f"<div class='notice'><b>Runtime:</b> {gpu_status()} · No application-level audio duration or file-size limit is enabled. "
-            "Estimated times are predictions that self-calibrate from this deployment's own completed jobs and adjust live if a job runs longer than predicted — not a guaranteed fixed duration.</div>"
+            f"<div class='notice'><b>Runtime:</b> {gpu_status()} · No application-level audio duration or file-size limit is enabled. "
+            "Estimated times are predictions that self-calibrate from this deployment's own completed jobs and adjust live if a job runs longer than predicted — not a guaranteed fixed duration.</div>"
         )
 
         gr.HTML(
             """
             <div class='hero'>
-              <h1>🔇 Audio Cleanup Studio</h1>
+              <h1>🔇 Audio Cleanup Studio</h1>
               <p>Remove silence, clean speech noise, and isolate voice or BGM without losing the original workflows.</p>
             </div>
             <div class='notice'><b>Privacy:</b> results are shown only to the current user. Uploaded and processed audio is archived privately for the administrator only; the public activity feed shows only the filename and selected action.</div>
@@ -1140,61 +1389,74 @@ def ui() -> gr.Blocks:
         with gr.Row():
             with gr.Column(scale=1):
                 audio_input = gr.Audio(
-                    label="📂 Upload Audio",
+                    label="📂 Upload Audio",
                     type="filepath",
                     sources=["upload", "microphone"],
                     format="wav",
                 )
+                silence_mode = gr.Radio(
+                    ["Custom value", "Auto (AI detect)"],
+                    value="Custom value",
+                    label="Silence Removal Mode",
+                    info="Custom = you choose how much silence to keep · Auto = silence is detected and removed automatically",
+                )
                 silence_threshold = gr.Number(
                     label="Keep Silence Up To (seconds)", value=0.05, minimum=0, precision=2
                 )
-                submit_btn = gr.Button("🔇 Remove Silence", variant="primary")
+                auto_style = gr.Radio(
+                    ["Natural", "Balanced", "Tight"],
+                    value="Balanced",
+                    label="Auto Cut Style",
+                    info="Natural = only long pauses trimmed · Balanced = recommended · Tight = fast-paced, very short gaps",
+                    visible=False,
+                )
+                submit_btn = gr.Button("🔇 Remove Silence", variant="primary")
             with gr.Column(scale=1):
-                audio_output = gr.Audio(label="â–¶ Play Audio")
-                file_output = gr.File(label="⬇ Download Audio File")
-                duration_output = gr.Textbox(label="📊 Duration Info", interactive=False)
+                audio_output = gr.Audio(label="▶ Play Audio")
+                file_output = gr.File(label="⬇ Download Audio File")
+                duration_output = gr.Textbox(label="📊 Duration Info", interactive=False)
 
-        remove_status = gr.Textbox(label="âš¡ Remove Silence Status", interactive=False)
-        live_log = gr.Textbox(label="🧾 Live Processing Log", lines=8, interactive=False, elem_classes=["log-box"])
-        eta_output = gr.Textbox(label="⏱ Estimated Time", interactive=False)
+        remove_status = gr.Textbox(label="⚡ Remove Silence Status", interactive=False)
+        live_log = gr.Textbox(label="🧾 Live Processing Log", lines=8, interactive=False, elem_classes=["log-box"])
+        eta_output = gr.Textbox(label="⏱ Estimated Time", interactive=False)
 
         gr.HTML("<hr>")
-        gr.Markdown("âš¡ **Hugging Face ZeroGPU:** ML processing uses the allocated CUDA GPU; CPU fallback is used only when CUDA is unavailable.")
-        gr.Markdown("## ✨ Audio Enhancer\nReal speech-noise suppression is used first. If it cannot initialise, the app transparently falls back to spectral denoising, rumble filtering, and loudness normalization.")
+        gr.Markdown("⚡ **Hugging Face ZeroGPU:** ML processing uses the allocated CUDA GPU; CPU fallback is used only when CUDA is unavailable.")
+        gr.Markdown("## ✨ Audio Enhancer\nReal speech-noise suppression is used first. If it cannot initialise, the app transparently falls back to spectral denoising, rumble filtering, and loudness normalization.")
         with gr.Row():
             with gr.Column(scale=1):
                 enhance_audio_input = gr.Audio(
-                    label="📂 Upload Audio for Enhancement",
+                    label="📂 Upload Audio for Enhancement",
                     type="filepath",
                     sources=["upload", "microphone"],
                 )
                 enhancement_strength = gr.Radio(["Light", "Balanced", "Strong"], value="Balanced", label="Noise Cleaning Strength")
-                enhance_btn = gr.Button("✨ Enhance Audio", variant="primary")
+                enhance_btn = gr.Button("✨ Enhance Audio", variant="primary")
             with gr.Column(scale=1):
-                enhanced_audio_output = gr.Audio(label="â–¶ Enhanced Audio")
-                enhanced_file_output = gr.File(label="⬇ Download Enhanced Audio")
-                enhance_status = gr.Textbox(label="âš¡ Enhancement Status", interactive=False)
+                enhanced_audio_output = gr.Audio(label="▶ Enhanced Audio")
+                enhanced_file_output = gr.File(label="⬇ Download Enhanced Audio")
+                enhance_status = gr.Textbox(label="⚡ Enhancement Status", interactive=False)
 
         gr.HTML("<hr>")
-        gr.Markdown("## 🎙️ Voice / BGM Isolation\nChoose this when you want **voice only** (remove BGM) or **BGM only** (remove voice). The two downloads are created together using Demucs separation.")
+        gr.Markdown("## 🎙️ Voice / BGM Isolation\nChoose this when you want **voice only** (remove BGM) or **BGM only** (remove voice). The two downloads are created together using Demucs separation.")
         with gr.Row():
             with gr.Column(scale=1):
                 isolate_audio_input = gr.Audio(
-                    label="📂 Upload Audio for Voice / BGM Isolation",
+                    label="📂 Upload Audio for Voice / BGM Isolation",
                     type="filepath",
                     sources=["upload", "microphone"],
                 )
                 separation_model = gr.Radio(["High quality", "Faster"], value="High quality", label="Separation Quality")
-                isolate_btn = gr.Button("🎙️ Isolate Voice & BGM", variant="primary")
+                isolate_btn = gr.Button("🎙️ Isolate Voice & BGM", variant="primary")
             with gr.Column(scale=1):
-                vocals_output = gr.Audio(label="🎤 Voice Only")
-                bgm_output = gr.Audio(label="🎵 BGM Only (Voice Removed)")
-                vocal_file_output = gr.File(label="⬇ Download Voice Only")
-                bgm_file_output = gr.File(label="⬇ Download BGM Only")
-                separation_status = gr.Textbox(label="âš¡ Voice / BGM Status", interactive=False)
+                vocals_output = gr.Audio(label="🎤 Voice Only")
+                bgm_output = gr.Audio(label="🎵 BGM Only (Voice Removed)")
+                vocal_file_output = gr.File(label="⬇ Download Voice Only")
+                bgm_file_output = gr.File(label="⬇ Download BGM Only")
+                separation_status = gr.Textbox(label="⚡ Voice / BGM Status", interactive=False)
 
         gr.HTML("<hr>")
-        gr.Markdown("## 🌐 Public Processing Activity\nThis is an activity count, not a count of verified people. It intentionally never exposes audio files or downloads.")
+        gr.Markdown("## 🌐 Public Processing Activity\nThis is an activity count, not a count of verified people. It intentionally never exposes audio files or downloads.")
         public_stats = gr.HTML(value=stats)
         public_history = gr.Dataframe(
             headers=["Audio filename", "Action", "Status", "Activity time"],
@@ -1206,7 +1468,7 @@ def ui() -> gr.Blocks:
         visitor_total_output = gr.Number(value=0, visible=False)
 
         gr.HTML("<hr>")
-        with gr.Accordion("🔐 Administrator: Private Audio Archive", open=False):
+        with gr.Accordion("🔐 Administrator: Private Audio Archive", open=False):
             gr.Markdown("Enter the administrator access code to view archived source and output audio. The access code is read from the Space Secret `ADMIN_ACCESS_CODE` and is never stored in the app database.")
             with gr.Row():
                 admin_code = gr.Textbox(label="Administrator access code", type="password")
@@ -1227,9 +1489,15 @@ def ui() -> gr.Blocks:
             return path
 
         audio_input.change(remember_original, inputs=audio_input, outputs=original_audio_state, api_name=False)
+        silence_mode.change(
+            toggle_silence_controls,
+            inputs=silence_mode,
+            outputs=[silence_threshold, auto_style],
+            api_name=False,
+        )
         submit_btn.click(
             process_remove_silence,
-            inputs=[audio_input, silence_threshold],
+            inputs=[audio_input, silence_threshold, silence_mode, auto_style],
             outputs=[audio_output, file_output, duration_output, processed_file_state, remove_status, live_log, eta_output, public_stats, public_history],
             api_name="process_audio",
         )
@@ -1291,4 +1559,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()