Update app.py

app.py

@@ -1,481 +1,1097 @@
-# import json
-# import io
+# import re
 # import os
-# from typing import Dict, Any, Tuple, Optional, List
+# import json
+# import math
+# import tempfile
+# from dataclasses import dataclass
+# from typing import List, Optional, Tuple, Dict, Any
 
 # import gradio as gr
-
-# # Optional deps
 # import numpy as np
-
-# try:
-#     import pandas as pd
-# except Exception as e:
-#     pd = None
-
-# # Audio backends
-# _AUDIO_BACKEND = None
-# try:
-#     import soundfile as sf  # best for wav/flac/ogg
-#     _AUDIO_BACKEND = "soundfile"
-# except Exception:
-#     sf = None
-
-# try:
-#     from pydub import AudioSegment  # fallback, works well with ffmpeg
-#     _AUDIO_BACKEND = _AUDIO_BACKEND or "pydub"
-# except Exception:
-#     AudioSegment = None
-
-
-# def _load_json(json_path: str) -> Dict[str, Any]:
-#     with open(json_path, "r", encoding="utf-8") as f:
-#         return json.load(f)
-
-
-# def _normalize_segments(data: Dict[str, Any]) -> List[Dict[str, Any]]:
-#     segs = data.get("segments", [])
-#     norm = []
-#     for i, s in enumerate(segs):
-#         # Some files have index only for valid segments; keep a stable row id
-#         row_id = s.get("index", None)
-#         if row_id is None:
-#             row_id = i  # fallback
-
-#         norm.append({
-#             "row_id": row_id,
-#             "start": float(s.get("start", 0.0)),
-#             "end": float(s.get("end", 0.0)),
-#             "dur": float(s.get("end", 0.0)) - float(s.get("start", 0.0)),
-#             "status": s.get("status", ""),
-#             "speaker": s.get("speaker", ""),
-#             "gender": s.get("gender", ""),
-#             "age_group": s.get("age_group", ""),
-#             "emotion": s.get("emotion", ""),
-#             "text": s.get("text", "") or "",
-#         })
-#     return norm
-
-
-# def _load_audio_to_np(audio_path: str) -> Tuple[np.ndarray, int]:
-#     """
-#     Returns mono float32 audio in [-1, 1], sample_rate
-#     """
-#     if sf is not None:
-#         try:
-#             y, sr = sf.read(audio_path, always_2d=False)
-#             if y.ndim == 2:
-#                 y = np.mean(y, axis=1)  # to mono
-#             y = y.astype(np.float32, copy=False)
-#             # If integer dtype, normalize (soundfile typically returns float already)
-#             if y.size > 0:
-#                 mx = np.max(np.abs(y))
-#                 if mx > 1.5:  # heuristic for int-like
-#                     y = y / mx
-#             return y, sr
-#         except Exception:
-#             pass
-
-#     if AudioSegment is not None:
-#         # Convert via pydub -> raw samples
-#         seg = AudioSegment.from_file(audio_path)
-#         sr = seg.frame_rate
-#         samples = np.array(seg.get_array_of_samples())
-#         if seg.channels > 1:
-#             samples = samples.reshape((-1, seg.channels)).mean(axis=1)
-#         # normalize by sample width
-#         max_val = float(1 << (8 * seg.sample_width - 1))
-#         y = (samples / max_val).astype(np.float32)
-#         return y, sr
-
-#     raise RuntimeError(
-#         "Cannot load audio: install soundfile or pydub (with ffmpeg)."
-#     )
-
-
-# def _slice_audio(y: np.ndarray, sr: int, start_s: float, end_s: float) -> Tuple[int, np.ndarray]:
-#     start_i = max(0, int(round(start_s * sr)))
-#     end_i = min(len(y), int(round(end_s * sr)))
-#     if end_i <= start_i:
-#         return sr, np.zeros((0,), dtype=np.float32)
-#     return sr, y[start_i:end_i]
-
-
-# def _safe_unique(values: List[str]) -> List[str]:
-#     out = []
-#     seen = set()
-#     for v in values:
-#         v = v or ""
-#         if v not in seen:
-#             out.append(v)
-#             seen.add(v)
-#     return out
-
-
-# def _build_df(segments: List[Dict[str, Any]]):
-#     if pd is None:
-#         # Fallback: return list-of-lists for gr.Dataframe
-#         headers = ["row_id", "start", "end", "dur", "status", "speaker", "gender", "age_group", "emotion", "text"]
-#         rows = [[s.get(h, "") for h in headers] for s in segments]
-#         return headers, rows, None
-#     df = pd.DataFrame(segments)
-#     # sort by start time
-#     df = df.sort_values(["start", "end"]).reset_index(drop=True)
-#     return df.columns.tolist(), df.values.tolist(), df
-
-
-# def _filter_segments(segments: List[Dict[str, Any]],
-#                      speaker: str, gender: str, age_group: str, emotion: str, status: str,
-#                      text_query: str) -> List[Dict[str, Any]]:
-#     def ok(v: str, sel: str) -> bool:
-#         if sel in (None, "", "ALL"):
-#             return True
-#         return (v or "") == sel
-
-#     tq = (text_query or "").strip().lower()
-
-#     out = []
-#     for s in segments:
-#         if not ok(s.get("speaker", ""), speaker):
+# import srt
+# from pydub import AudioSegment
+
+# from langdetect import DetectorFactory, detect_langs
+# DetectorFactory.seed = 0  # deterministic
+
+
+# # -----------------------------
+# # Data structures
+# # -----------------------------
+# @dataclass
+# class Cue:
+#     start: float
+#     end: float
+#     text: str
+
+
+# # -----------------------------
+# # Language utilities
+# # -----------------------------
+# LANG_LABELS = ["原文(不指定)", "中文", "English", "日本語"]
+
+# def normalize_lang_code(code: str) -> str:
+#     c = (code or "").lower()
+#     if c.startswith("zh"):
+#         return "中文"
+#     if c == "en":
+#         return "English"
+#     if c == "ja":
+#         return "日本語"
+#     return "其他"
+
+# def detect_language_label(text: str) -> Dict[str, Any]:
+#     t = (text or "").strip()
+#     if not t:
+#         return {"raw_code": None, "raw_prob": None, "label": None, "normalized_label": None}
+#     t = t.replace("\n", " ").strip()[:400]
+#     try:
+#         langs = detect_langs(t)
+#         if not langs:
+#             return {"raw_code": None, "raw_prob": None, "label": None, "normalized_label": None}
+#         top = langs[0]
+#         raw_code = getattr(top, "lang", None)
+#         raw_prob = float(getattr(top, "prob", 0.0)) if top else None
+#         norm = normalize_lang_code(raw_code)
+#         return {
+#             "raw_code": raw_code,
+#             "raw_prob": round(raw_prob, 3) if raw_prob is not None else None,
+#             "label": norm if norm != "其他" else "原文(不指定)",
+#             "normalized_label": norm,
+#         }
+#     except Exception:
+#         return {"raw_code": None, "raw_prob": None, "label": None, "normalized_label": None}
+
+# def check_declared_mismatch(declared: str, detected_norm: Optional[str]) -> bool:
+#     if declared == "原文(不指定)":
+#         return False
+#     if detected_norm is None:
+#         return True
+#     if detected_norm == "其他":
+#         return True
+#     return detected_norm != declared
+
+# def analyze_language_for_cues(cues: List[Cue]) -> Dict[str, Any]:
+#     counts = {"中文": 0, "English": 0, "日本語": 0, "其他": 0}
+#     for c in cues:
+#         d = detect_language_label(c.text)
+#         norm = d.get("normalized_label")
+#         if norm in counts:
+#             counts[norm] += 1
+#     dominant = max(counts.items(), key=lambda x: x[1])[0] if cues else None
+#     return {"counts": counts, "dominant_norm": dominant}
+
+
+# # -----------------------------
+# # Subtitle parsing
+# # -----------------------------
+# _TAG_RE = re.compile(r"</?[^>]+?>", re.IGNORECASE)
+# _VTT_TIME_RE = re.compile(
+#     r"(?P<start>\d{2}:\d{2}:\d{2}\.\d{3}|\d{1,2}:\d{2}\.\d{3})\s*-->\s*"
+#     r"(?P<end>\d{2}:\d{2}:\d{2}\.\d{3}|\d{1,2}:\d{2}\.\d{3})"
+# )
+
+# def _strip_tags(text: str) -> str:
+#     text = _TAG_RE.sub("", text)
+#     text = text.replace("<c>", "").replace("</c>", "")
+#     return text.strip()
+
+# def _time_to_seconds(t: str) -> float:
+#     t = t.strip().split()[0]
+#     parts = t.split(":")
+#     if len(parts) == 3:
+#         h = int(parts[0])
+#         m = int(parts[1])
+#         s = float(parts[2])
+#         return h * 3600 + m * 60 + s
+#     if len(parts) == 2:
+#         m = int(parts[0])
+#         s = float(parts[1])
+#         return m * 60 + s
+#     raise ValueError(f"Unsupported time format: {t}")
+
+# def parse_vtt(content: str) -> List[Cue]:
+#     content = content.replace("\ufeff", "")
+#     content = re.sub(r"^\s*WEBVTT.*?\n", "", content, flags=re.IGNORECASE)
+#     blocks = re.split(r"\r?\n\r?\n", content.strip())
+#     cues: List[Cue] = []
+#     for block in blocks:
+#         lines = [ln.rstrip("\n") for ln in re.split(r"\r?\n", block) if ln.strip() != ""]
+#         if not lines:
 #             continue
-#         if not ok(s.get("gender", ""), gender):
+#         time_line_idx = None
+#         for idx in range(min(2, len(lines))):
+#             if "-->" in lines[idx]:
+#                 time_line_idx = idx
+#                 break
+#         if time_line_idx is None:
 #             continue
-#         if not ok(s.get("age_group", ""), age_group):
+#         m = _VTT_TIME_RE.search(lines[time_line_idx])
+#         if not m:
 #             continue
-#         if not ok(s.get("emotion", ""), emotion):
+#         start = _time_to_seconds(m.group("start"))
+#         end = _time_to_seconds(m.group("end"))
+#         if not (math.isfinite(start) and math.isfinite(end)) or end <= start:
 #             continue
-#         if not ok(s.get("status", ""), status):
+#         text_lines = lines[time_line_idx + 1 :]
+#         text = _strip_tags("\n".join(text_lines)).strip()
+#         if not text:
 #             continue
-#         if tq:
-#             if tq not in (s.get("text", "") or "").lower():
-#                 continue
-#         out.append(s)
-#     return out
+#         cues.append(Cue(start=start, end=end, text=text))
+#     cues.sort(key=lambda x: x.start)
+#     return cues
+
+# def parse_srt(content: str) -> List[Cue]:
+#     content = content.replace("\ufeff", "")
+#     subs = list(srt.parse(content))
+#     cues: List[Cue] = []
+#     for sub in subs:
+#         cues.append(
+#             Cue(
+#                 start=sub.start.total_seconds(),
+#                 end=sub.end.total_seconds(),
+#                 text=sub.content.strip(),
+#             )
+#         )
+#     cues.sort(key=lambda x: x.start)
+#     return cues
+
+# def parse_subtitle_file(path: Optional[str]) -> List[Cue]:
+#     if not path:
+#         return []
+#     with open(path, "r", encoding="utf-8") as f:
+#         content = f.read()
+#     head = content.lstrip()[:80].upper()
+#     ext = os.path.splitext(path)[1].lower()
+#     if "WEBVTT" in head or ext == ".vtt":
+#         return parse_vtt(content)
+#     return parse_srt(content)
+
+
+# # -----------------------------
+# # Alignment
+# # -----------------------------
+# def align_by_time(
+#     a: List[Cue],
+#     b: List[Cue],
+#     max_mid_diff: float = 1.5,
+# ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+#     aligned: List[Dict[str, Any]] = []
+#     i, j = 0, 0
+#     matched_a = set()
+#     matched_b = set()
+
+#     while i < len(a) and j < len(b):
+#         x = a[i]
+#         y = b[j]
+#         mid_x = (x.start + x.end) / 2
+#         mid_y = (y.start + y.end) / 2
+#         diff = mid_x - mid_y
+
+#         if abs(diff) <= max_mid_diff:
+#             # global window for "corresponding part"
+#             g_start = min(x.start, y.start)
+#             g_end = max(x.end, y.end)
+#             aligned.append(
+#                 {
+#                     "idx": len(aligned) + 1,
+#                     "start": g_start,
+#                     "end": g_end,
+#                     "en_start": x.start,
+#                     "en_end": x.end,
+#                     "zh_start": y.start,
+#                     "zh_end": y.end,
+#                     "text_en": x.text,
+#                     "text_zh": y.text,
+#                 }
+#             )
+#             matched_a.add(i)
+#             matched_b.add(j)
+#             i += 1
+#             j += 1
+#         elif diff < 0:
+#             i += 1
+#         else:
+#             j += 1
+
+#     stats = {
+#         "trackA_total": len(a),
+#         "trackB_total": len(b),
+#         "aligned_pairs": len(aligned),
+#         "trackA_unmatched": len(a) - len(matched_a),
+#         "trackB_unmatched": len(b) - len(matched_b),
+#         "max_mid_diff_sec": max_mid_diff,
+#     }
+#     return aligned, stats
+
+
+# # -----------------------------
+# # Audio processing / QC
+# # -----------------------------
+# def load_audio(path: str) -> AudioSegment:
+#     return AudioSegment.from_file(path)
+
+# def segment_to_wav_file(audio: AudioSegment, start_s: float, end_s: float) -> str:
+#     start_ms = max(0, int(start_s * 1000))
+#     end_ms = max(start_ms + 1, int(end_s * 1000))
+#     seg = audio[start_ms:end_ms]
+#     tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+#     tmp.close()
+#     seg.export(tmp.name, format="wav")
+#     return tmp.name
+
+# def compute_dbfs(audio: AudioSegment) -> float:
+#     v = audio.dBFS
+#     if v == float("-inf"):
+#         return -120.0
+#     return float(v)
+
+# def qc_on_aligned_segments(
+#     audio_a: AudioSegment,
+#     audio_b: AudioSegment,
+#     aligned: List[Dict[str, Any]],
+#     silence_dbfs_threshold: float = -50.0,
+#     low_dbfs_threshold: float = -40.0,
+# ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+#     issues: List[Dict[str, Any]] = []
+#     a_levels = []
+#     b_levels = []
+
+#     for seg in aligned:
+#         a_start, a_end = seg["en_start"], seg["en_end"]
+#         b_start, b_end = seg["zh_start"], seg["zh_end"]
+
+#         a = audio_a[int(a_start * 1000) : int(a_end * 1000)]
+#         b = audio_b[int(b_start * 1000) : int(b_end * 1000)]
+
+#         a_dbfs = compute_dbfs(a)
+#         b_dbfs = compute_dbfs(b)
+
+#         a_levels.append(a_dbfs)
+#         b_levels.append(b_dbfs)
+
+#         problems = []
+#         if a_dbfs <= silence_dbfs_threshold:
+#             problems.append("Track A 静音/近静音")
+#         elif a_dbfs <= low_dbfs_threshold:
+#             problems.append("Track A 音量偏低")
+
+#         if b_dbfs <= silence_dbfs_threshold:
+#             problems.append("Track B 静音/近静音")
+#         elif b_dbfs <= low_dbfs_threshold:
+#             problems.append("Track B 音量偏低")
+
+#         if abs(a_dbfs - b_dbfs) >= 12.0:
+#             problems.append("两路音量差异过大(≥12dB)")
+
+#         if problems:
+#             issues.append(
+#                 {
+#                     "segment": seg["idx"],
+#                     "time": f"{seg['start']:.2f}-{seg['end']:.2f}s",
+#                     "A_time": f"{a_start:.2f}-{a_end:.2f}s",
+#                     "B_time": f"{b_start:.2f}-{b_end:.2f}s",
+#                     "problems": problems,
+#                     "text_A": seg["text_en"][:120] + ("..." if len(seg["text_en"]) > 120 else ""),
+#                     "text_B": seg["text_zh"][:120] + ("..." if len(seg["text_zh"]) > 120 else ""),
+#                     "A_dbfs": round(a_dbfs, 1),
+#                     "B_dbfs": round(b_dbfs, 1),
+#                 }
+#             )
 
+#     def _safe_mean(xs):
+#         return float(np.mean(xs)) if xs else 0.0
+
+#     qc_stats = {
+#         "aligned_pairs": len(aligned),
+#         "issue_segments": len(issues),
+#         "A_avg_dbfs": round(_safe_mean(a_levels), 1),
+#         "B_avg_dbfs": round(_safe_mean(b_levels), 1),
+#         "A_min_dbfs": round(float(np.min(a_levels)), 1) if a_levels else None,
+#         "B_min_dbfs": round(float(np.min(b_levels)), 1) if b_levels else None,
+#         "silence_dbfs_threshold": silence_dbfs_threshold,
+#         "low_dbfs_threshold": low_dbfs_threshold,
+#     }
+#     return issues, qc_stats
+
+
+# # -----------------------------
+# # Interactive HTML table (buttons per row)
+# # -----------------------------
+# def _escape_html(s: str) -> str:
+#     return (s or "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+# def build_interactive_table_html(aligned: List[Dict[str, Any]]) -> str:
+#     max_rows = 2000
+#     aligned_view = aligned[:max_rows]
+
+#     rows_html = []
+#     for seg in aligned_view:
+#         idx = seg["idx"]
+#         t = f'{seg["start"]:.2f}-{seg["end"]:.2f}'
+#         a_t = f'{seg["en_start"]:.2f}-{seg["en_end"]:.2f}'
+#         b_t = f'{seg["zh_start"]:.2f}-{seg["zh_end"]:.2f}'
+#         a_txt = _escape_html(seg["text_en"])
+#         b_txt = _escape_html(seg["text_zh"])
+
+#         a_lang = _escape_html(seg.get("en_lang_label") or "-")
+#         b_lang = _escape_html(seg.get("zh_lang_label") or "-")
+#         a_conf = seg.get("en_lang_prob")
+#         b_conf = seg.get("zh_lang_prob")
+#         a_conf_s = f"{a_conf:.3f}" if isinstance(a_conf, (int, float)) else "-"
+#         b_conf_s = f"{b_conf:.3f}" if isinstance(b_conf, (int, float)) else "-"
+
+#         a_bad = seg.get("en_lang_mismatch", False)
+#         b_bad = seg.get("zh_lang_mismatch", False)
+#         a_cls = "bad" if a_bad else "ok"
+#         b_cls = "bad" if b_bad else "ok"
+
+#         btns = (
+#             f'<button class="segbtn a" onclick="__playSeg({idx}, \'a\')">A</button>'
+#             f'<button class="segbtn b" onclick="__playSeg({idx}, \'b\')">B</button>'
+#             f'<button class="segbtn both" onclick="__playSeg({idx}, \'both\')">同时</button>'
+#         )
 
-# def _make_waveform_plot(y: np.ndarray, sr: int, segments: List[Dict[str, Any]]):
-#     # Optional: simple waveform plot with vertical lines on segment boundaries
-#     try:
-#         import matplotlib.pyplot as plt
-#     except Exception:
-#         return None
+#         rows_html.append(
+#             f"""
+#             <tr>
+#               <td class="mono">{idx:04d}</td>
+#               <td class="mono">{t}</td>
+#               <td class="btncell">{btns}</td>
+#               <td class="textcell">{a_txt}</td>
+#               <td class="textcell">{b_txt}</td>
+#               <td class="mono">{a_t}</td>
+#               <td class="mono">{b_t}</td>
+#               <td class="mono {a_cls}">{a_lang} ({a_conf_s})</td>
+#               <td class="mono {b_cls}">{b_lang} ({b_conf_s})</td>
+#             </tr>
+#             """.strip()
+#         )
 
-#     if y.size == 0:
-#         return None
+#     # IMPORTANT FIX:
+#     # - __qs must be `#${id}`, not `#${{id}}`
+#     # - action_box/action_btn must exist in DOM (we keep them and hide via CSS)
+#     # - Wait for audio src to change before play (avoid playing old segment)
+#     table_html = f"""
+# <div class="segwrap">
+#   <div class="note">
+#     点击每行按钮可生成并播放片段（A / B / 同时）。若浏览器阻止自动播放，请在右侧播放器手动点一次播放键。
+#   </div>
+#   <div class="tablewrap">
+#     <table class="segtable">
+#       <thead>
+#         <tr>
+#           <th>#</th>
+#           <th>Global(s)</th>
+#           <th>Play</th>
+#           <th>Track A</th>
+#           <th>Track B</th>
+#           <th>A time</th>
+#           <th>B time</th>
+#           <th>A Lang</th>
+#           <th>B Lang</th>
+#         </tr>
+#       </thead>
+#       <tbody>
+#         {"".join(rows_html)}
+#       </tbody>
+#     </table>
+#   </div>
+# </div>
+
+# <style>
+#   .segwrap {{ margin-top: 8px; }}
+#   .note {{ font-size: 12px; opacity: 0.85; margin-bottom: 8px; }}
+#   .tablewrap {{ overflow: auto; max-height: 560px; border: 1px solid rgba(127,127,127,0.25); border-radius: 8px; }}
+#   table.segtable {{ width: 100%; border-collapse: collapse; }}
+#   table.segtable th, table.segtable td {{ border-bottom: 1px solid rgba(127,127,127,0.18); padding: 8px; vertical-align: top; }}
+#   table.segtable thead th {{ position: sticky; top: 0; background: rgba(250,250,250,0.95); z-index: 1; }}
+#   .mono {{ font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; white-space: nowrap; }}
+#   .textcell {{ min-width: 320px; white-space: pre-wrap; }}
+#   .btncell {{ white-space: nowrap; min-width: 150px; }}
+#   .segbtn {{
+#     padding: 4px 10px;
+#     margin-right: 6px;
+#     border-radius: 8px;
+#     border: 1px solid rgba(127,127,127,0.35);
+#     background: white;
+#     cursor: pointer;
+#     font-size: 12px;
+#   }}
+#   .segbtn:hover {{ background: rgba(0,0,0,0.04); }}
+#   .segbtn.both {{ font-weight: 800; }}
+#   .ok {{ color: inherit; }}
+#   .bad {{ color: #b00020; font-weight: 800; }}
+# </style>
+
+# <script>
+#   function __gradioAppRoot() {{
+#     const ga = document.querySelector("gradio-app");
+#     return ga ? ga.shadowRoot : document;
+#   }}
+
+#   function __qs(id) {{
+#     const root = __gradioAppRoot();
+#     return root.querySelector(`#${{id}}`);
+#   }}
+
+#   function __setTextboxValue(elemId, value) {{
+#     const box = __qs(elemId);
+#     if (!box) return false;
+#     const input = box.querySelector("textarea, input");
+#     if (!input) return false;
+#     input.value = value;
+#     input.dispatchEvent(new Event("input", {{ bubbles: true }}));
+#     return true;
+#   }}
+
+#   function __clickButton(elemId) {{
+#     const btn = __qs(elemId);
+#     if (!btn) return false;
+#     const realBtn = btn.querySelector("button");
+#     if (!realBtn) return false;
+#     realBtn.click();
+#     return true;
+#   }}
+
+#   function __getAudioTag(containerElemId) {{
+#     const c = __qs(containerElemId);
+#     if (!c) return null;
+#     return c.querySelector("audio");
+#   }}
+
+#   window.__desiredPlayMode = null; // "a" | "b" | "both"
+#   window.__desiredPlayNonce = 0;
+
+#   function __waitAndPlay(nonce, prevASrc, prevBSrc) {{
+#     let tries = 0;
+#     const maxTries = 80; // ~16s
+#     const intervalMs = 200;
+
+#     const timer = setInterval(() => {{
+#       tries += 1;
+#       if (window.__desiredPlayNonce !== nonce) {{
+#         clearInterval(timer);
+#         return;
+#       }}
+
+#       const aAudio = __getAudioTag("a_audio_seg");
+#       const bAudio = __getAudioTag("b_audio_seg");
+
+#       if (!aAudio && !bAudio) {{
+#         if (tries >= maxTries) clearInterval(timer);
+#         return;
+#       }}
+
+#       const mode = window.__desiredPlayMode;
+
+#       const aReady = aAudio && (aAudio.src && aAudio.src !== prevASrc) && aAudio.readyState >= 2;
+#       const bReady = bAudio && (bAudio.src && bAudio.src !== prevBSrc) && bAudio.readyState >= 2;
+
+#       const canPlay =
+#         (mode === "a" && aReady) ||
+#         (mode === "b" && bReady) ||
+#         (mode === "both" && aReady && bReady);
+
+#       if (canPlay) {{
+#         try {{
+#           if (mode === "a") {{
+#             if (bAudio) bAudio.pause();
+#             aAudio.currentTime = 0;
+#             aAudio.play();
+#           }} else if (mode === "b") {{
+#             if (aAudio) aAudio.pause();
+#             bAudio.currentTime = 0;
+#             bAudio.play();
+#           }} else if (mode === "both") {{
+#             aAudio.currentTime = 0;
+#             bAudio.currentTime = 0;
+#             aAudio.play();
+#             bAudio.play();
+#           }}
+#         }} catch (e) {{}}
+#         clearInterval(timer);
+#         return;
+#       }}
+
+#       if (tries >= maxTries) {{
+#         clearInterval(timer);
+#       }}
+#     }}, intervalMs);
+#   }}
+
+#   function __playSeg(idx, mode) {{
+#     window.__desiredPlayMode = mode;
+#     window.__desiredPlayNonce += 1;
+#     const nonce = window.__desiredPlayNonce;
+
+#     const aAudio = __getAudioTag("a_audio_seg");
+#     const bAudio = __getAudioTag("b_audio_seg");
+#     const prevASrc = aAudio ? aAudio.src : "";
+#     const prevBSrc = bAudio ? bAudio.src : "";
+
+#     const payload = JSON.stringify({{ idx: idx, mode: mode }});
+#     const ok1 = __setTextboxValue("action_box", payload);
+#     const ok2 = __clickButton("action_btn");
+
+#     if (ok1 && ok2) {{
+#       __waitAndPlay(nonce, prevASrc, prevBSrc);
+#     }} else {{
+#       console.warn("Failed to trigger backend action.", ok1, ok2);
+#     }}
+#   }}
+# </script>
+#     """.strip()
+
+#     if len(aligned) > max_rows:
+#         table_html = (
+#             f"<div style='margin:8px 0;font-size:12px;opacity:.85;'>"
+#             f"提示：对齐片段数为 {len(aligned)}，为保证渲染性能仅展示前 {max_rows} 行。</div>\n"
+#             + table_html
+#         )
+#     return table_html
 
-#     # downsample for plotting speed
-#     max_points = 20000
-#     if len(y) > max_points:
-#         step = len(y) // max_points
-#         y_plot = y[::step]
-#         t = np.linspace(0, len(y) / sr, num=len(y_plot))
-#     else:
-#         y_plot = y
-#         t = np.linspace(0, len(y) / sr, num=len(y))
-
-#     fig = plt.figure(figsize=(10, 3))
-#     ax = fig.add_subplot(111)
-#     ax.plot(t, y_plot, linewidth=0.7)
-#     ax.set_title("Waveform (segment boundaries)")
-#     ax.set_xlabel("Time (s)")
-#     ax.set_ylabel("Amplitude")
-
-#     # add some boundaries (avoid too many lines)
-#     if segments:
-#         # show up to 120 boundaries to avoid clutter
-#         boundaries = []
-#         for s in segments:
-#             boundaries.append(float(s.get("start", 0.0)))
-#             boundaries.append(float(s.get("end", 0.0)))
-#         boundaries = sorted(set(boundaries))
-#         if len(boundaries) > 120:
-#             # evenly sample
-#             idx = np.linspace(0, len(boundaries) - 1, 120).astype(int)
-#             boundaries = [boundaries[i] for i in idx]
-
-#         for b in boundaries:
-#             ax.axvline(b, linewidth=0.5, alpha=0.25)
-
-#     fig.tight_layout()
-#     return fig
-
-
-# def load_assets(audio_file, json_file):
-#     if audio_file is None or json_file is None:
-#         raise gr.Error("请同时上传音频文件和JSON字幕文件。")
-
-#     audio_path = audio_file
-#     json_path = json_file
-
-#     data = _load_json(json_path)
-#     segments = _normalize_segments(data)
-
-#     # load audio
-#     y, sr = _load_audio_to_np(audio_path)
-
-#     # build options
-#     speakers = ["ALL"] + _safe_unique([s.get("speaker", "") for s in segments if s.get("speaker", "")])
-#     genders = ["ALL"] + _safe_unique([s.get("gender", "") for s in segments if s.get("gender", "")])
-#     ages = ["ALL"] + _safe_unique([s.get("age_group", "") for s in segments if s.get("age_group", "")])
-#     emotions = ["ALL"] + _safe_unique([s.get("emotion", "") for s in segments if s.get("emotion", "")])
-#     statuses = ["ALL"] + _safe_unique([s.get("status", "") for s in segments if s.get("status", "")])
-
-#     headers, rows, _ = _build_df(segments)
-
-#     # waveform plot (optional)
-#     fig = _make_waveform_plot(y, sr, segments)
-
-#     # store in state
-#     state = {
-#         "audio_path": audio_path,
-#         "json_path": json_path,
-#         "audio_sr": sr,
-#         "audio_y": y,
-#         "segments": segments,
-#         "headers": headers,
-#         "rows_full": rows,
-#     }
 
-#     info_md = (
-#         f"**audio_name**: `{data.get('audio_name','')}`  \n"
-#         f"**segments**: {len(segments)}  \n"
-#         f"**audio**: sr={sr}, duration≈{len(y)/sr:.2f}s  \n"
-#         f"**backend**: `{_AUDIO_BACKEND}`"
-#     )
+# # -----------------------------
+# # Segment generation (core fix: global window + offset)
+# # -----------------------------
+# def _pick_window(seg: Dict[str, Any], mode: str, offset_a: float, offset_b: float) -> Tuple[float, float, float, float]:
+#     """
+#     mode:
+#       - "global": use seg["start"]/["end"] for BOTH tracks
+#       - "per_track": use seg["en_start"]/["en_end"] for A, seg["zh_start"]/["zh_end"] for B
+#     offsets are applied per track.
+#     Returns: (a_start, a_end, b_start, b_end)
+#     """
+#     if mode == "per_track":
+#         a_start, a_end = seg["en_start"], seg["en_end"]
+#         b_start, b_end = seg["zh_start"], seg["zh_end"]
+#     else:
+#         # global window (recommended)
+#         a_start, a_end = seg["start"], seg["end"]
+#         b_start, b_end = seg["start"], seg["end"]
+
+#     a_start = max(0.0, a_start + float(offset_a))
+#     a_end = max(a_start + 0.01, a_end + float(offset_a))
+#     b_start = max(0.0, b_start + float(offset_b))
+#     b_end = max(b_start + 0.01, b_end + float(offset_b))
+#     return a_start, a_end, b_start, b_end
+
+
+# # -----------------------------
+# # Gradio callbacks
+# # -----------------------------
+# def parse_align_and_qc(
+#     audio_a_path: Optional[str],
+#     audio_b_path: Optional[str],
+#     sub_a_path: Optional[str],
+#     sub_b_path: Optional[str],
+#     declared_a_lang: str,
+#     declared_b_lang: str,
+#     crop_mode: str,
+#     offset_a: float,
+#     offset_b: float,
+#     max_mid_diff: float,
+#     silence_th: float,
+#     low_th: float,
+# ):
+#     if not audio_a_path or not audio_b_path:
+#         return (
+#             [],
+#             "",
+#             {"error": "请同时上传 Track A 与 Track B 音频。"},
+#             [],
+#             None,
+#             None,
+#             gr.update(choices=[], value=None),
+#             None,
+#         )
 
-#     return (
-#         state,
-#         gr.update(value=info_md),
-#         gr.update(choices=speakers, value="ALL"),
-#         gr.update(choices=genders, value="ALL"),
-#         gr.update(choices=ages, value="ALL"),
-#         gr.update(choices=emotions, value="ALL"),
-#         gr.update(choices=statuses, value="ALL"),
-#         gr.update(value=rows, headers=headers),
-#         fig
-#     )
+#     try:
+#         cues_a = parse_subtitle_file(sub_a_path) if sub_a_path else []
+#         cues_b = parse_subtitle_file(sub_b_path) if sub_b_path else []
+
+#         if not cues_a or not cues_b:
+#             return (
+#                 [],
+#                 "",
+#                 {"error": "请同时提供两路字幕（SRT/VTT）。", "A_cues": len(cues_a), "B_cues": len(cues_b)},
+#                 [],
+#                 audio_a_path,
+#                 audio_b_path,
+#                 gr.update(choices=[], value=None),
+#                 None,
+#             )
 
+#         # overall language stats
+#         a_lang_stats = analyze_language_for_cues(cues_a)
+#         b_lang_stats = analyze_language_for_cues(cues_b)
+
+#         aligned, align_stats = align_by_time(cues_a, cues_b, max_mid_diff=max_mid_diff)
+
+#         # per-segment language + mismatch issues
+#         lang_mismatch_issues = []
+#         for seg in aligned:
+#             da = detect_language_label(seg["text_en"])
+#             db = detect_language_label(seg["text_zh"])
+#             seg["en_lang_label"] = da.get("label")
+#             seg["en_lang_prob"] = da.get("raw_prob")
+#             seg["en_lang_norm"] = da.get("normalized_label")
+#             seg["zh_lang_label"] = db.get("label")
+#             seg["zh_lang_prob"] = db.get("raw_prob")
+#             seg["zh_lang_norm"] = db.get("normalized_label")
+
+#             seg["en_lang_mismatch"] = check_declared_mismatch(declared_a_lang, seg["en_lang_norm"])
+#             seg["zh_lang_mismatch"] = check_declared_mismatch(declared_b_lang, seg["zh_lang_norm"])
+
+#             if seg["en_lang_mismatch"] or seg["zh_lang_mismatch"]:
+#                 problems = []
+#                 if seg["en_lang_mismatch"]:
+#                     problems.append(f"Track A 声明={declared_a_lang} 检测={seg['en_lang_label']}")
+#                 if seg["zh_lang_mismatch"]:
+#                     problems.append(f"Track B 声明={declared_b_lang} 检测={seg['zh_lang_label']}")
+#                 lang_mismatch_issues.append(
+#                     {
+#                         "segment": seg["idx"],
+#                         "time": f"{seg['start']:.2f}-{seg['end']:.2f}s",
+#                         "type": "LanguageMismatch",
+#                         "problems": problems,
+#                         "text_A": seg["text_en"][:120] + ("..." if len(seg["text_en"]) > 120 else ""),
+#                         "text_B": seg["text_zh"][:120] + ("..." if len(seg["text_zh"]) > 120 else ""),
+#                     }
+#                 )
+
+#         # dataframe rows
+#         rows = []
+#         for seg in aligned:
+#             rows.append(
+#                 [
+#                     seg["idx"],
+#                     f'{seg["start"]:.2f}',
+#                     f'{seg["end"]:.2f}',
+#                     seg["text_en"],
+#                     seg["text_zh"],
+#                     f'{seg["en_start"]:.2f}-{seg["en_end"]:.2f}',
+#                     f'{seg["zh_start"]:.2f}-{seg["zh_end"]:.2f}',
+#                 ]
+#             )
 
-# def apply_filters(state, speaker, gender, age_group, emotion, status, text_query):
-#     if not state:
-#         raise gr.Error("请先加载音频和JSON。")
+#         # audio QC (still based on per-track subtitle times; keep original semantics)
+#         audio_a = load_audio(audio_a_path)
+#         audio_b = load_audio(audio_b_path)
+#         issues_qc, qc_stats = qc_on_aligned_segments(
+#             audio_a, audio_b, aligned,
+#             silence_dbfs_threshold=silence_th,
+#             low_dbfs_threshold=low_th
+#         )
 
-#     segments = state["segments"]
-#     filtered = _filter_segments(segments, speaker, gender, age_group, emotion, status, text_query)
+#         issues_all = lang_mismatch_issues + issues_qc
+
+#         stats = {
+#             "alignment": align_stats,
+#             "qc": qc_stats,
+#             "language": {
+#                 "declared": {"TrackA": declared_a_lang, "TrackB": declared_b_lang},
+#                 "detected_overall": {
+#                     "TrackA_dominant_norm": a_lang_stats["dominant_norm"],
+#                     "TrackB_dominant_norm": b_lang_stats["dominant_norm"],
+#                     "TrackA_counts": a_lang_stats["counts"],
+#                     "TrackB_counts": b_lang_stats["counts"],
+#                 },
+#                 "segment_mismatch_count": len(lang_mismatch_issues),
+#             },
+#             "segment_crop": {
+#                 "mode": crop_mode,
+#                 "offset_a_sec": offset_a,
+#                 "offset_b_sec": offset_b,
+#                 "note": "若对比播放不对应：优先使用“对齐全局时间(推荐)”，并微调 Track A/B 时间偏移。",
+#             }
+#         }
+
+#         choices = [f'{seg["idx"]:04d} | {seg["start"]:.2f}-{seg["end"]:.2f}s' for seg in aligned]
+#         selector_update = gr.update(choices=choices, value=(choices[0] if choices else None))
+
+#         state = {
+#             "aligned": aligned,
+#             "audio_a_path": audio_a_path,
+#             "audio_b_path": audio_b_path,
+#             "declared": {"TrackA": declared_a_lang, "TrackB": declared_b_lang},
+#             "crop_mode": crop_mode,
+#             "offset_a": float(offset_a),
+#             "offset_b": float(offset_b),
+#         }
+
+#         html_table = build_interactive_table_html(aligned)
+
+#         return rows, html_table, stats, issues_all, audio_a_path, audio_b_path, selector_update, state
+
+#     except Exception as e:
+#         return (
+#             [],
+#             "",
+#             {"error": f"解析/对齐失败: {str(e)}"},
+#             [{"error": str(e)}],
+#             audio_a_path,
+#             audio_b_path,
+#             gr.update(choices=[], value=None),
+#             None,
+#         )
 
-#     headers, rows, _ = _build_df(filtered)
+# def _parse_selector_value(v: Optional[str]) -> Optional[int]:
+#     if not v:
+#         return None
+#     m = re.match(r"^\s*(\d+)\s*\|", v)
+#     if not m:
+#         return None
+#     return int(m.group(1))
 
-#     state2 = dict(state)
-#     state2["rows_filtered"] = rows
-#     state2["headers_filtered"] = headers
-#     state2["segments_filtered"] = filtered
+# def make_segment_audio_by_idx(idx: int, state: Optional[Dict[str, Any]]):
+#     if not state or "aligned" not in state:
+#         return None, None, {"error": "请先完成字幕解析与对齐。"}
 
-#     return state2, gr.update(value=rows, headers=headers)
+#     aligned = state["aligned"]
+#     if idx < 1 or idx > len(aligned):
+#         return None, None, {"error": "片段索引越界。"}
 
+#     seg = aligned[idx - 1]
+#     audio_a_path = state["audio_a_path"]
+#     audio_b_path = state["audio_b_path"]
+#     crop_mode = state.get("crop_mode", "global")
+#     offset_a = float(state.get("offset_a", 0.0))
+#     offset_b = float(state.get("offset_b", 0.0))
 
-# def _get_segment_by_row(state, row_data: List[Any]) -> Dict[str, Any]:
-#     # row_data is one row from the displayed dataframe
-#     # We reconstruct by column names
-#     headers = None
-#     if "headers_filtered" in state:
-#         headers = state["headers_filtered"]
-#     else:
-#         headers = state["headers"]
-
-#     row_map = {headers[i]: row_data[i] for i in range(min(len(headers), len(row_data)))}
-
-#     # We try to match by (start,end,text,speaker) or row_id
-#     target_row_id = row_map.get("row_id", None)
-#     start = float(row_map.get("start", 0.0))
-#     end = float(row_map.get("end", 0.0))
-#     text = (row_map.get("text", "") or "")
-
-#     candidates = state.get("segments_filtered", state["segments"])
-#     for s in candidates:
-#         if target_row_id is not None and str(s.get("row_id")) == str(target_row_id):
-#             return s
-
-#     # fallback match by time+text
-#     for s in candidates:
-#         if abs(float(s.get("start", 0.0)) - start) < 1e-3 and abs(float(s.get("end", 0.0)) - end) < 1e-3:
-#             if (s.get("text", "") or "") == text:
-#                 return s
-
-#     # last resort: return nearest start
-#     best = None
-#     best_d = 1e9
-#     for s in candidates:
-#         d = abs(float(s.get("start", 0.0)) - start)
-#         if d < best_d:
-#             best_d = d
-#             best = s
-#     return best or candidates[0]
-
-
-# def on_row_select(evt: gr.SelectData, state):
+#     try:
+#         audio_a = load_audio(audio_a_path)
+#         audio_b = load_audio(audio_b_path)
+
+#         a_start, a_end, b_start, b_end = _pick_window(seg, crop_mode, offset_a, offset_b)
+
+#         a_wav = segment_to_wav_file(audio_a, a_start, a_end)
+#         b_wav = segment_to_wav_file(audio_b, b_start, b_end)
+
+#         info = {
+#             "segment": idx,
+#             "global_time": f'{seg["start"]:.2f}-{seg["end"]:.2f}s',
+#             "crop_mode": crop_mode,
+#             "offset_a_sec": offset_a,
+#             "offset_b_sec": offset_b,
+#             "crop_A_time": f"{a_start:.2f}-{a_end:.2f}s",
+#             "crop_B_time": f"{b_start:.2f}-{b_end:.2f}s",
+#             "subtitle_A_time": f'{seg["en_start"]:.2f}-{seg["en_end"]:.2f}s',
+#             "subtitle_B_time": f'{seg["zh_start"]:.2f}-{seg["zh_end"]:.2f}s',
+#             "text_A": seg["text_en"],
+#             "text_B": seg["text_zh"],
+#         }
+#         return a_wav, b_wav, info
+#     except Exception as e:
+#         return None, None, {"error": f"生成片段音频失败: {str(e)}"}
+
+# def make_segment_audio(selector_value: Optional[str], state: Optional[Dict[str, Any]]):
+#     idx = _parse_selector_value(selector_value)
+#     if idx is None:
+#         return None, None, {"error": "请选择一个有效片段。"}
+#     return make_segment_audio_by_idx(idx, state)
+
+# def make_segment_audio_from_action(action_json: str, state: Optional[Dict[str, Any]]):
 #     """
-#     evt.value: selected cell value (not enough)
-#     evt.index: (row, col)
-#     We need to access the dataframe contents; Gradio passes it through component state in newer versions.
-#     We'll rely on evt.row_value if available; else use a hidden state approach via gr.Dataframe 'value'.
+#     action_json: {"idx": <int>, "mode": "a"/"b"/"both"}
+#     mode is only used by frontend for play policy; backend always returns both segment audios.
 #     """
-#     if not state:
-#         raise gr.Error("请先加载音频和JSON。")
-
-#     row_value = getattr(evt, "row_value", None)
-#     if row_value is None:
-#         # If not available, we cannot slice; return a hint
-#         return (
-#             None,
-#             gr.update(value="无法读取选中行数据（你的Gradio版本可能较旧）。建议升级gradio>=4。"),
-#             gr.update(value=""),
-#         )
+#     try:
+#         payload = json.loads(action_json or "{}")
+#         idx = int(payload.get("idx"))
+#     except Exception:
+#         return None, None, {"error": "动作解析失败（action_json 无效）。"}
+#     return make_segment_audio_by_idx(idx, state)
 
-#     seg = _get_segment_by_row(state, row_value)
-
-#     y = state["audio_y"]
-#     sr = state["audio_sr"]
-#     start = float(seg.get("start", 0.0))
-#     end = float(seg.get("end", 0.0))
-#     sr_out, y_seg = _slice_audio(y, sr, start, end)
-
-#     # Build display
-#     md = (
-#         f"### 选中片段\n"
-#         f"- **time**: `{start:.3f}s` → `{end:.3f}s` (dur≈{end-start:.3f}s)\n"
-#         f"- **status**: `{seg.get('status','')}`\n"
-#         f"- **speaker**: `{seg.get('speaker','')}`\n"
-#         f"- **gender**: `{seg.get('gender','')}`\n"
-#         f"- **age_group**: `{seg.get('age_group','')}`\n"
-#         f"- **emotion**: `{seg.get('emotion','')}`\n"
+# def clear_all():
+#     return (
+#         None, None, None, None,
+#         "原文(不指定)", "原文(不指定)",
+#         "global", 0.0, 0.0,
+#         [], "", {}, [],
+#         None, None,
+#         gr.update(choices=[], value=None),
+#         None,
+#         None, None, {},
+#         "",
 #     )
 
-#     text = seg.get("text", "") or ""
-#     if not text.strip():
-#         text = "(empty)"
 
-#     # Gradio Audio can take (sr, np.ndarray)
-#     return ( (sr_out, y_seg), gr.update(value=md), gr.update(value=text) )
+# # -----------------------------
+# # UI
+# # -----------------------------
+# CSS = """
+# /* Keep components in DOM for injected JS to locate them */
+# .dom-hidden { display: none !important; }
+# """
+
+# with gr.Blocks(css=CSS) as demo:
+#     gr.Markdown(
+#         """
+# # 可视化语音质检平台（交互逐行播放 + 语言一致性 + 对齐裁剪）
+# - 交互表格每行播放：A / B / 同时
+# - “对齐全局时间(推荐)”可显著减少“对比不对应”的听感问题
+# - “时间偏移”用于修正音频头部静音/时间轴偏差
+#         """.strip()
+#     )
 
+#     state = gr.State(value=None)
 
-# def build_app():
-#     with gr.Blocks(title="Audio Segment Explorer") as demo:
-#         gr.Markdown(
-#             "# 音频分段可视化与分段播放（Speaker / Gender / Age / Emotion）\n"
-#             "上传音频 + JSON（包含 `segments`）即可查看分段列表，点击任意分段可直接播放该段音频。"
-#         )
+#     # Must exist in DOM (NOT visible=False)
+#     action_box = gr.Textbox(
+#         label="__action_box",
+#         value="",
+#         elem_id="action_box",
+#         elem_classes=["dom-hidden"],
+#     )
+#     action_btn = gr.Button(
+#         "__action_btn",
+#         elem_id="action_btn",
+#         elem_classes=["dom-hidden"],
+#     )
 
-#         state = gr.State(value={})
-
-#         with gr.Row():
-#             audio_in = gr.Audio(label="上传音频文件", type="filepath")
-#             json_in = gr.File(label="上传字幕JSON文件", file_types=[".json"])
-
-#         load_btn = gr.Button("加载 / 解析", variant="primary")
-#         info = gr.Markdown()
-
-#         with gr.Row():
-#             speaker_dd = gr.Dropdown(label="Speaker", choices=["ALL"], value="ALL")
-#             gender_dd = gr.Dropdown(label="Gender", choices=["ALL"], value="ALL")
-#             age_dd = gr.Dropdown(label="Age group", choices=["ALL"], value="ALL")
-#             emotion_dd = gr.Dropdown(label="Emotion", choices=["ALL"], value="ALL")
-#             status_dd = gr.Dropdown(label="Status", choices=["ALL"], value="ALL")
-
-#         text_query = gr.Textbox(label="Text contains（可选）", placeholder="输入关键词过滤 text（支持阿拉伯语/英文）")
-#         filter_btn = gr.Button("应用筛选")
-
-#         with gr.Row():
-#             df = gr.Dataframe(
-#                 label="Segments（点击行以播放该段）",
-#                 headers=["row_id", "start", "end", "dur", "status", "speaker", "gender", "age_group", "emotion", "text"],
-#                 datatype=["number", "number", "number", "number", "str", "str", "str", "str", "str", "str"],
-#                 wrap=True,
-#                 interactive=False,
-#                 max_height=420,
+#     with gr.Row():
+#         with gr.Column(scale=1):
+#             gr.Markdown("## 1) 上传文件")
+#             audio_a = gr.File(
+#                 label="Track A 音频/视频",
+#                 file_types=[".mp3", ".wav", ".m4a", ".flac", ".ogg", ".aac", ".mp4", ".mov", ".avi"],
+#                 type="filepath",
+#             )
+#             audio_b = gr.File(
+#                 label="Track B 音频/视频",
+#                 file_types=[".mp3", ".wav", ".m4a", ".flac", ".ogg", ".aac", ".mp4", ".mov", ".avi"],
+#                 type="filepath",
 #             )
 
-#         plot = gr.Plot(label="Waveform（可选）")
+#             sub_a = gr.File(
+#                 label="Track A 字幕（.srt/.vtt）",
+#                 file_types=[".srt", ".vtt", ".txt"],
+#                 type="filepath",
+#             )
+#             sub_b = gr.File(
+#                 label="Track B 字幕（.srt/.vtt）",
+#                 file_types=[".srt", ".vtt", ".txt"],
+#                 type="filepath",
+#             )
 
-#         with gr.Row():
-#             seg_audio = gr.Audio(label="分段播放", type="numpy")
-#             seg_meta = gr.Markdown()
-#         seg_text = gr.Textbox(label="该段转写文本", lines=4)
+#             gr.Markdown("## 2) 声明语言（用于一致性检查）")
+#             declared_a_lang = gr.Dropdown(
+#                 label="Track A 声明语言",
+#                 choices=LANG_LABELS,
+#                 value="原文(不指定)",
+#             )
+#             declared_b_lang = gr.Dropdown(
+#                 label="Track B 声明语言",
+#                 choices=LANG_LABELS,
+#                 value="原文(不指定)",
+#             )
 
-#         # events
-#         load_btn.click(
-#             fn=load_assets,
-#             inputs=[audio_in, json_in],
-#             outputs=[state, info, speaker_dd, gender_dd, age_dd, emotion_dd, status_dd, df, plot],
-#         )
+#             gr.Markdown("## 3) 片段裁剪设置（解决“不对应”）")
+#             crop_mode = gr.Radio(
+#                 label="裁剪基准",
+#                 choices=[
+#                     ("对齐全局时间(推荐)", "global"),
+#                     ("各自字幕时间", "per_track"),
+#                 ],
+#                 value="global",
+#             )
+#             offset_a = gr.Slider(
+#                 label="Track A 时间偏移（秒，可为负）",
+#                 minimum=-30.0,
+#                 maximum=30.0,
+#                 value=0.0,
+#                 step=0.1,
+#             )
+#             offset_b = gr.Slider(
+#                 label="Track B 时间偏移（秒，可为负）",
+#                 minimum=-30.0,
+#                 maximum=30.0,
+#                 value=0.0,
+#                 step=0.1,
+#             )
 
-#         filter_btn.click(
-#             fn=apply_filters,
-#             inputs=[state, speaker_dd, gender_dd, age_dd, emotion_dd, status_dd, text_query],
-#             outputs=[state, df],
-#         )
+#             gr.Markdown("## 4) 对齐与质检参数")
+#             max_mid_diff = gr.Slider(
+#                 label="两路字幕对齐阈值（中点时间差，秒）",
+#                 minimum=0.3,
+#                 maximum=5.0,
+#                 value=1.5,
+#                 step=0.1,
+#             )
+#             silence_th = gr.Slider(
+#                 label="静音/近静音阈值（dBFS）",
+#                 minimum=-80,
+#                 maximum=-20,
+#                 value=-50,
+#                 step=1,
+#             )
+#             low_th = gr.Slider(
+#                 label="音量偏低阈值（dBFS）",
+#                 minimum=-80,
+#                 maximum=-20,
+#                 value=-40,
+#                 step=1,
+#             )
 
-#         df.select(
-#             fn=on_row_select,
-#             inputs=[state],
-#             outputs=[seg_audio, seg_meta, seg_text],
-#         )
+#             with gr.Row():
+#                 btn_run = gr.Button("解析对齐 + 质检", variant="primary")
+#                 btn_clear = gr.Button("清空", variant="secondary")
+
+#         with gr.Column(scale=2):
+#             with gr.Tabs():
+#                 with gr.TabItem("交互播放表格（推荐）"):
+#                     interactive_table = gr.HTML()
+
+#                 with gr.TabItem("分段对照表（Dataframe）"):
+#                     seg_table = gr.Dataframe(
+#                         headers=["#", "start(s)", "end(s)", "Track A", "Track B", "A time", "B time"],
+#                         datatype=["number", "str", "str", "str", "str", "str", "str"],
+#                         interactive=False,
+#                         wrap=True,
+#                     )
+
+#                 with gr.TabItem("统计概览"):
+#                     stats = gr.JSON(label="统计信息（对齐 + QC + 语言一致性 + 裁剪设置）")
+
+#                 with gr.TabItem("问题片段"):
+#                     issues = gr.JSON(label="问题列表（含 LanguageMismatch）")
+
+#                 with gr.TabItem("音频对比播放"):
+#                     gr.Markdown("### 原始音频（整段）")
+#                     player_a_full = gr.Audio(label="Track A 原始音频", interactive=False)
+#                     player_b_full = gr.Audio(label="Track B 原始音频", interactive=False)
+
+#                     gr.Markdown("### 选择片段并生成对比音频（备用方式）")
+#                     selector = gr.Dropdown(label="片段选择", choices=[], value=None)
+#                     btn_make = gr.Button("生成所选片段（两路）", variant="primary")
+
+#                     # elem_id used by injected JS
+#                     player_a_seg = gr.Audio(label="Track A 片段", interactive=False, elem_id="a_audio_seg")
+#                     player_b_seg = gr.Audio(label="Track B 片段", interactive=False, elem_id="b_audio_seg")
+#                     seg_info = gr.JSON(label="片段信息（含裁剪窗口）")
+
+#     btn_run.click(
+#         fn=parse_align_and_qc,
+#         inputs=[
+#             audio_a, audio_b, sub_a, sub_b,
+#             declared_a_lang, declared_b_lang,
+#             crop_mode, offset_a, offset_b,
+#             max_mid_diff, silence_th, low_th
+#         ],
+#         outputs=[
+#             seg_table, interactive_table, stats, issues,
+#             player_a_full, player_b_full,
+#             selector, state
+#         ],
+#     )
 
-#         gr.Markdown(
-#             "### 小提示\n"
-#             "- `invalid` 片段通常是静音/噪声/无文本，你可以用 **Status=valid** 过滤。\n"
-#             "- 如果音频是 mp3 且 `soundfile` 无法读取，代码会自动尝试 `pydub`（Spaces 一般有 ffmpeg）。"
-#         )
+#     btn_make.click(
+#         fn=make_segment_audio,
+#         inputs=[selector, state],
+#         outputs=[player_a_seg, player_b_seg, seg_info],
+#     )
 
-#     return demo
+#     # triggered by table buttons
+#     action_btn.click(
+#         fn=make_segment_audio_from_action,
+#         inputs=[action_box, state],
+#         outputs=[player_a_seg, player_b_seg, seg_info],
+#     )
 
+#     btn_clear.click(
+#         fn=clear_all,
+#         inputs=[],
+#         outputs=[
+#             audio_a, audio_b, sub_a, sub_b,
+#             declared_a_lang, declared_b_lang,
+#             crop_mode, offset_a, offset_b,
+#             seg_table, interactive_table, stats, issues,
+#             player_a_full, player_b_full,
+#             selector, state,
+#             player_a_seg, player_b_seg, seg_info,
+#             action_box
+#         ],
+#     )
 
 # if __name__ == "__main__":
-#     demo = build_app()
 #     demo.launch()
 
+
 import json
 import numpy as np
 import gradio as gr
 
-from huggingface_hub import hf_hub_download, list_repo_files
+from huggingface_hub import (
+    list_repo_files,
+    hf_hub_download,
+)
 
 import soundfile as sf
 
-# =====================
-# 固定配置（你的数据）
-# =====================
+
+# =====================================================
+# 固定配置（你的 Dataset 真实路径）
+# =====================================================
 REPO_ID = "AlexTYJ/Multilingual-ASR-Benchmark"
+REPO_TYPE = "dataset"
+
 AUDIO_DIR = "audio/testbatch/ARE"
 JSON_DIR = "text/ref/testbatch/ARE"
 
 
-# =====================
+# =====================================================
 # 工具函数
-# =====================
+# =====================================================
 
 def list_are_audio_files():
-    files = list_repo_files(REPO_ID)
+    """
+    列出 ARE 目录下所有音频文件
+    """
+    files = list_repo_files(
+        repo_id=REPO_ID,
+        repo_type=REPO_TYPE,
+    )
+
     audio_files = [
         f for f in files
-        if f.startswith(AUDIO_DIR) and f.lower().endswith((".wav", ".mp3", ".flac"))
+        if f.startswith(AUDIO_DIR)
+        and f.lower().endswith((".wav", ".mp3", ".flac"))
     ]
     audio_files.sort()
     return audio_files
 
 
-def load_audio_and_json(audio_path):
-    # ---- 推导 json 路径 ----
+def load_audio_and_json(audio_path: str):
+    """
+    给定 audio 路径：
+    - 下载音频
+    - 推导并下载对应 json
+    - 解析 segments
+    """
     filename = audio_path.split("/")[-1]
-    json_path = f"{JSON_DIR}/{filename.replace('.wav', '.json').replace('.mp3', '.json').replace('.flac', '.json')}"
+    base = filename.rsplit(".", 1)[0]
+    json_path = f"{JSON_DIR}/{base}.json"
 
     # ---- 下载 ----
-    local_audio = hf_hub_download(REPO_ID, audio_path)
-    local_json = hf_hub_download(REPO_ID, json_path)
+    local_audio = hf_hub_download(
+        repo_id=REPO_ID,
+        filename=audio_path,
+        repo_type=REPO_TYPE,
+    )
+
+    local_json = hf_hub_download(
+        repo_id=REPO_ID,
+        filename=json_path,
+        repo_type=REPO_TYPE,
+    )
 
     # ---- 读音频 ----
     audio, sr = sf.read(local_audio)
     if audio.ndim == 2:
         audio = audio.mean(axis=1)
+    audio = audio.astype(np.float32)
 
     # ---- 读 JSON ----
     with open(local_json, "r", encoding="utf-8") as f:
@@ -485,9 +1101,9 @@ def load_audio_and_json(audio_path):
     for i, s in enumerate(data["segments"]):
         segments.append({
             "row_id": s.get("index", i),
-            "start": float(s["start"]),
-            "end": float(s["end"]),
-            "dur": float(s["end"] - s["start"]),
+            "start": float(s.get("start", 0.0)),
+            "end": float(s.get("end", 0.0)),
+            "dur": float(s.get("end", 0.0) - s.get("start", 0.0)),
             "status": s.get("status", ""),
             "speaker": s.get("speaker", ""),
             "gender": s.get("gender", ""),
@@ -500,14 +1116,16 @@ def load_audio_and_json(audio_path):
 
 
 def slice_audio(audio, sr, start, end):
-    return sr, audio[int(start * sr): int(end * sr)]
+    s = max(0, int(start * sr))
+    e = min(len(audio), int(end * sr))
+    return sr, audio[s:e]
 
 
-# =====================
-# Gradio 交互逻辑
-# =====================
+# =====================================================
+# Gradio 回调
+# =====================================================
 
-def on_select_file(audio_path):
+def on_load_audio(audio_path):
     audio, sr, segments, audio_name = load_audio_and_json(audio_path)
 
     rows = [
@@ -529,7 +1147,7 @@ def on_select_file(audio_path):
     state = {
         "audio": audio,
         "sr": sr,
-        "segments": segments
+        "segments": segments,
     }
 
     return state, rows, info
@@ -537,28 +1155,39 @@ def on_select_file(audio_path):
 
 def on_select_segment(evt: gr.SelectData, state):
     row = evt.row_value
-    start, end = float(row[1]), float(row[2])
 
-    sr, audio_seg = slice_audio(state["audio"], state["sr"], start, end)
+    start = float(row[1])
+    end = float(row[2])
+
+    sr, audio_seg = slice_audio(
+        state["audio"],
+        state["sr"],
+        start,
+        end
+    )
 
     meta = (
-        f"- **speaker**: {row[5]}\n"
-        f"- **gender**: {row[6]}\n"
-        f"- **age_group**: {row[7]}\n"
-        f"- **emotion**: {row[8]}"
+        f"- **speaker**: `{row[5]}`\n"
+        f"- **gender**: `{row[6]}`\n"
+        f"- **age_group**: `{row[7]}`\n"
+        f"- **emotion**: `{row[8]}`\n"
+        f"- **status**: `{row[4]}`"
     )
 
-    return (sr, audio_seg), meta, row[9]
+    text = row[9] if row[9].strip() else "(empty)"
+
+    return (sr, audio_seg), meta, text
 
 
-# =====================
+# =====================================================
 # UI
-# =====================
+# =====================================================
 
 with gr.Blocks(title="ARE Audio Segment Explorer") as demo:
     gr.Markdown(
-        "# 🎧 ARE 音频 & 字幕可视化（Hugging Face Dataset）\n"
-        "数据来源：`AlexTYJ/Multilingual-ASR-Benchmark`"
+        "# 🎧 ARE 音频分段可视化（Hugging Face Dataset）\n"
+        "**Dataset**: `AlexTYJ/Multilingual-ASR-Benchmark`\n\n"
+        "从 Hugging Face Hub 直接读取音频与字幕，不需要上传文件。"
     )
 
     state = gr.State()
@@ -566,12 +1195,12 @@ with gr.Blocks(title="ARE Audio Segment Explorer") as demo:
     audio_files = list_are_audio_files()
 
     audio_selector = gr.Dropdown(
-        choices=audio_files,
         label="选择音频文件（ARE）",
-        value=audio_files[0] if audio_files else None
+        choices=audio_files,
+        value=audio_files[0] if audio_files else None,
     )
 
-    load_btn = gr.Button("加载", variant="primary")
+    load_btn = gr.Button("加载音频 & 字幕", variant="primary")
     info = gr.Markdown()
 
     df = gr.Dataframe(
@@ -592,7 +1221,7 @@ with gr.Blocks(title="ARE Audio Segment Explorer") as demo:
     text = gr.Textbox(label="字幕文本", lines=4)
 
     load_btn.click(
-        on_select_file,
+        on_load_audio,
         inputs=audio_selector,
         outputs=[state, df, info],
     )
@@ -603,5 +1232,4 @@ with gr.Blocks(title="ARE Audio Segment Explorer") as demo:
         outputs=[audio_out, meta, text],
     )
 
-demo.launch()
-
+demo.launch()