| """Side-by-side inspector/editor for one audio file plus two RTTM annotations. |
| |
| Serves a localhost page with an audio player with interval-selection |
| playback, and two stacked panels of per-speaker timeline tracks (RTTM A |
| on top, RTTM B below) sharing one time axis. Speakers of A and B are |
| auto-matched by maximal overlap so matched speakers share a color and |
| vertical order, and a "diff" strip between the panels highlights every |
| region where the two annotations disagree (speech only in A, only in B, |
| or attributed to different speakers). |
| |
| Both annotations are editable in place: move/resize segments, reassign |
| the speaker, split at the playhead, delete, create segments and speaker |
| lanes, with undo/redo. Each RTTM saves to "<original-stem>_new.rttm" |
| next to the original file. |
| |
| Usage: |
| python double_rttm_viewer.py audio.wav a.rttm b.rttm [--port 8766] |
| open: http://127.0.0.1:8766 |
| |
| The RTTM files are parsed for SPEAKER lines: |
| SPEAKER <file-id> <chan> <onset> <duration> <NA> <NA> <speaker> ... |
| For non-WAV audio the duration is taken from the browser's decoder, |
| with the last RTTM segment end as the initial estimate. |
| """ |
| import argparse |
| import io |
| import json |
| import mimetypes |
| import os |
| import re |
| import wave |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
|
|
|
|
| def parse_rttm(path): |
| """Return (segments, file_id, channel) from SPEAKER lines of an RTTM.""" |
| segments = [] |
| file_id, chan = None, None |
| with open(path, encoding="utf-8") as f: |
| for ln, line in enumerate(f, 1): |
| line = line.strip() |
| if not line or line.startswith((";", "#")): |
| continue |
| parts = line.split() |
| if parts[0] != "SPEAKER": |
| continue |
| if len(parts) < 8: |
| raise ValueError(f"{path}:{ln}: malformed SPEAKER line") |
| start, dur = float(parts[3]), float(parts[4]) |
| segments.append({"start": start, "end": start + dur, |
| "speaker": parts[7]}) |
| file_id = file_id or parts[1] |
| chan = chan or parts[2] |
| if not segments: |
| raise ValueError(f"{path}: no SPEAKER lines found") |
| segments.sort(key=lambda s: s["start"]) |
| return segments, file_id, chan |
|
|
|
|
| def load_audio(path): |
| """Return (bytes, content-type, duration-or-None).""" |
| with open(path, "rb") as f: |
| data = f.read() |
| if data[:4] == b"RIFF": |
| with wave.open(io.BytesIO(data)) as w: |
| return data, "audio/x-wav", w.getnframes() / w.getframerate() |
| ctype = mimetypes.guess_type(path)[0] or "audio/mpeg" |
| return data, ctype, None |
|
|
|
|
| PAGE = """<!DOCTYPE html> |
| <html lang="zh"> |
| <head> |
| <meta charset="utf-8"> |
| <title>双 RTTM 对比编辑器</title> |
| <style> |
| :root { --bg:#14161a; --panel:#1e2128; --text:#e6e6e6; --dim:#9aa0aa; |
| --accent:#4da3ff; --sel:rgba(255,210,80,.25); --selborder:#ffd250; |
| --aonly:#ffb020; --bonly:#3fd0ff; --mismatch:#ff5470; |
| --labelw:210px; } |
| * { box-sizing:border-box; } |
| body { margin:0; background:var(--bg); color:var(--text); |
| font:14px/1.5 system-ui,"Segoe UI",sans-serif; } |
| header { display:flex; align-items:center; gap:12px; flex-wrap:wrap; |
| padding:8px 16px; background:var(--panel); |
| border-bottom:1px solid #000; position:sticky; top:0; z-index:6; } |
| header .title { font-weight:600; } |
| header .dim { color:var(--dim); font-size:12px; } |
| button, input[type=text], input[type=number] { background:#2a2e37; |
| color:var(--text); border:1px solid #3a3f4a; border-radius:6px; |
| padding:4px 10px; font-size:13px; cursor:pointer; } |
| button:hover { border-color:var(--accent); } |
| button:disabled { opacity:.4; cursor:default; } |
| button.dirty { border-color:var(--selborder); color:var(--selborder); } |
| input[type=text], input[type=number] { cursor:text; |
| font-variant-numeric:tabular-nums; } |
| input[type=text]:focus, input[type=number]:focus { |
| border-color:var(--selborder); outline:none; } |
| #controls { display:flex; align-items:center; gap:10px; flex-wrap:wrap; |
| padding:6px 16px; } |
| #audio { width:100%; } |
| .selinfo { color:var(--dim); font-size:13px; } |
| .selinfo b { color:var(--selborder); font-weight:600; } |
| #zoomwrap { margin-left:auto; display:flex; align-items:center; gap:6px; |
| color:var(--dim); font-size:12px; } |
| #diffstats { font-size:13px; } |
| #diffstats b { font-weight:600; } |
| .sw { display:inline-block; width:9px; height:9px; border-radius:2px; |
| margin:0 3px 0 10px; vertical-align:baseline; } |
| #editbar { display:none; align-items:center; gap:8px; flex-wrap:wrap; |
| margin:0 16px 6px; padding:6px 12px; background:#262b35; |
| border:1px solid var(--selborder); border-radius:8px; } |
| #editbar .tag { font-weight:600; color:var(--selborder); } |
| #editbar input[type=text] { width:90px; } |
| #editbar #ebspk { width:120px; } |
| #tracks-outer { margin:0 16px 24px; border:1px solid #2a2e37; |
| border-radius:8px; overflow-x:auto; background:var(--panel); } |
| #tracks { position:relative; min-width:100%; } |
| #ruler { position:relative; height:26px; border-bottom:1px solid #2a2e37; |
| cursor:crosshair; user-select:none; } |
| .tick { position:absolute; top:0; height:100%; border-left:1px solid #333842; |
| color:var(--dim); font-size:10px; padding:2px 0 0 3px; } |
| .panel-sep { position:relative; height:28px; background:#171a20; |
| border-bottom:1px solid #262a32; } |
| .panel-sep .lane-label { font-size:12px; max-width:none; color:var(--dim); |
| pointer-events:auto; } |
| .panel-sep b { color:var(--text); } |
| .panel-sep button { padding:1px 8px; font-size:11px; } |
| .lane { position:relative; height:34px; border-bottom:1px solid #262a32; } |
| .lane-label { position:sticky; left:0; z-index:5; display:inline-flex; |
| align-items:center; gap:6px; height:100%; padding:0 8px; |
| width:var(--labelw); background:var(--panel); |
| border-right:1px solid #2a2e37; |
| font-size:12px; white-space:nowrap; |
| overflow:hidden; text-overflow:ellipsis; pointer-events:none; } |
| .panel-sep .lane-label { width:auto; min-width:var(--labelw); } |
| .gutter-mask { position:sticky; left:0; z-index:5; display:inline-block; |
| width:var(--labelw); height:100%; background:var(--panel); |
| border-right:1px solid #2a2e37; } |
| .lane-label .swatch { width:10px; height:10px; border-radius:2px; flex:none; } |
| .lane-label button { pointer-events:auto; padding:0 6px; font-size:11px; } |
| .seg { position:absolute; top:7px; height:20px; border-radius:3px; |
| opacity:.85; cursor:grab; min-width:2px; } |
| .seg:hover { opacity:1; outline:1px solid #fff; z-index:2; } |
| .seg.selected { opacity:1; outline:2px solid #fff; z-index:3; } |
| .difflane { position:relative; height:26px; background:#101216; |
| border-bottom:1px solid #262a32; } |
| .difflane .lane-label { font-size:11px; } |
| .diffseg { position:absolute; top:6px; height:14px; border-radius:2px; |
| opacity:.9; cursor:pointer; min-width:2px; } |
| .diffseg:hover { opacity:1; outline:1px solid #fff; z-index:2; } |
| #playhead { position:absolute; top:0; bottom:0; width:1px; |
| background:#ff5555; z-index:4; pointer-events:none; } |
| #selbox { position:absolute; top:0; bottom:0; background:var(--sel); |
| border-left:1px solid var(--selborder); |
| border-right:1px solid var(--selborder); |
| z-index:1; pointer-events:none; display:none; } |
| #hint { padding:0 16px 12px; color:var(--dim); font-size:12px; } |
| #err { color:#ff7070; padding:8px 16px; display:none; } |
| #savemsg { font-size:12px; color:#7ddf8f; } |
| </style> |
| </head> |
| <body> |
| <header> |
| <span class="title">双 RTTM 对比编辑器</span> |
| <span class="dim" id="fname"></span> |
| <span class="dim" id="rowinfo"></span> |
| <span style="margin-left:auto"></span> |
| <button id="savea"></button> |
| <button id="saveb"></button> |
| <span id="savemsg"></span> |
| </header> |
| <div id="err"></div> |
| <div id="controls"> |
| <audio id="audio" controls preload="auto"></audio> |
| </div> |
| <div id="controls"> |
| <button id="playsel" disabled>▶ 播放选区</button> |
| <label class="dim"><input type="checkbox" id="loop"> 循环</label> |
| <button id="clearsel" disabled>清除选区</button> |
| <span class="dim">选区</span> |
| <input type="text" id="selstart" placeholder="起 (秒或分:秒)" style="width:110px"> |
| <span class="dim">→</span> |
| <input type="text" id="selend" placeholder="止 (秒或分:秒)" style="width:110px"> |
| <button id="applysel">应用</button> |
| <span class="selinfo" id="selinfo">拖动空白选择区间;单击色块选中编辑</span> |
| <label class="dim" style="margin-left:auto"><input type="checkbox" id="follow" checked> 跟随播放</label> |
| <span id="zoomwrap" style="margin-left:0">缩放 |
| <input type="range" id="zoom" min="0" max="100" value="0" style="width:140px"> |
| <span id="zoomval">1×</span> |
| </span> |
| </div> |
| <div id="controls"> |
| <span id="diffstats" class="dim">…</span> |
| <span class="dim" style="margin-left:auto">忽略短于</span> |
| <input type="number" id="mindiff" value="0.25" min="0" step="0.05" style="width:70px"> |
| <span class="dim">s 的差异</span> |
| <button id="remap" title="按当前标注重新计算 A↔B 说话人配对与配色">重算说话人配对</button> |
| </div> |
| <div id="editbar"> |
| <span class="tag" id="ebtitle"></span> |
| <span class="dim">说话人</span><input type="text" id="ebspk" list="spklist"> |
| <datalist id="spklist"></datalist> |
| <span class="dim">起</span><input type="text" id="ebstart"> |
| <span class="dim">止</span><input type="text" id="ebend"> |
| <span class="dim" id="ebdur"></span> |
| <button id="ebapply">应用 (Enter)</button> |
| <button id="ebplay">▶ 播放该段</button> |
| <button id="ebsplit">✂ 在播放头拆分 (S)</button> |
| <button id="ebdel">🗑 删除 (Del)</button> |
| <button id="ebclose">取消 (Esc)</button> |
| </div> |
| <div id="tracks-outer"><div id="tracks"> |
| <div id="ruler"></div> |
| <div id="lanes"></div> |
| <div id="selbox"></div> |
| <div id="playhead" style="left:0"></div> |
| </div></div> |
| <div id="hint">单击色块=选中编辑 · 双击色块=播放该段 · 拖动色块=移动 · |
| 拖动色块边缘=调整边界 · Alt+在泳道空白拖动=新建段 · 泳道"+段"=把选区加为该说话人的段 · |
| 空白拖动=选区 / 单击=定位 · Del=删除 S=拆分 Ctrl+Z/Ctrl+Shift+Z=撤销/重做 · |
| 空格=播放/暂停 ←/→=±5s Shift+←/→=±0.5s Esc=取消</div> |
| <script> |
| const $ = id => document.getElementById(id); |
| const audio = $('audio'); |
| const PALETTE = ['#4da3ff','#ff9f43','#2ecc71','#e74c3c','#a55eea','#f1c40f', |
| '#1abc9c','#fd79a8','#74b9ff','#e17055','#81ecec','#b8e994', |
| '#ffbe76','#badc58','#7ed6df','#e056fd','#f8a5c2','#63cdda']; |
| const CATNAME = {aonly:'仅A有语音', bonly:'仅B有语音', mismatch:'说话人不一致'}; |
| const CATCOLOR = {aonly:'var(--aonly)', bonly:'var(--bonly)', |
| mismatch:'var(--mismatch)'}; |
| let meta = null, dur = 0, zoomFactor = 1; |
| let sel = null; // {start, end} seconds |
| let dragging = null; // select | create | move | resize-l | resize-r |
| let selected = null; // {file:'a'|'b', id} |
| let mapping = null; // {pairs, colorOf:Map, nextColor} |
| let diffRegions = [], diffStats = null; |
| let nextId = 1; |
| const undoStack = {a:[], b:[]}, redoStack = {a:[], b:[]}; |
| const dirty = {a:false, b:false}; |
| |
| function fmt(t) { |
| const h = Math.floor(t/3600), m = Math.floor(t%3600/60), s = t%60; |
| return (h? h+':' : '') + String(m).padStart(2,'0') + ':' + |
| s.toFixed(2).padStart(5,'0'); |
| } |
| const LABEL_W = 210; // keep in sync with --labelw |
| function pxPerSec() { |
| const w = $('tracks-outer').clientWidth - LABEL_W - 2; |
| return (w / dur) * zoomFactor; |
| } |
| // content x-position of time t (timeline starts right of the label gutter) |
| function tX(t) { return LABEL_W + t * pxPerSec(); } |
| function xToTime(clientX) { |
| const r = $('tracks').getBoundingClientRect(); |
| return Math.min(dur, Math.max(0, |
| (clientX - r.left - LABEL_W) / pxPerSec())); |
| } |
| const natCmp = (a, b) => a.localeCompare(b, undefined, {numeric:true}); |
| function findSeg(file, id) { |
| return meta.files[file].segments.find(s => s.id === id); |
| } |
| |
| /* ---------- speaker mapping (A<->B) and colors ---------- */ |
| |
| function speakerList(file) { |
| const f = meta.files[file]; |
| const spks = new Set(f.segments.map(s => s.speaker)); |
| f.extraSpeakers.forEach(s => spks.add(s)); |
| return [...spks]; |
| } |
| |
| // pair A/B speakers maximizing total overlap duration; exact bitmask DP |
| // over the smaller side (fallback: greedy when both sides are large) |
| function bestPairs(ov, nA, nB) { |
| let flip = false; |
| if (nB > nA) { // make B (mask side) the smaller one |
| flip = true; |
| const t = []; |
| for (let j = 0; j < nB; j++) { t.push(ov.map(row => row[j])); } |
| ov = t; [nA, nB] = [nB, nA]; |
| } |
| let pairs = []; |
| if (nB > 14) { // greedy fallback |
| const all = []; |
| for (let i = 0; i < nA; i++) |
| for (let j = 0; j < nB; j++) |
| if (ov[i][j] > 0) all.push([ov[i][j], i, j]); |
| all.sort((x, y) => y[0] - x[0]); |
| const ua = new Set(), ub = new Set(); |
| for (const [, i, j] of all) { |
| if (ua.has(i) || ub.has(j)) continue; |
| ua.add(i); ub.add(j); pairs.push([i, j]); |
| } |
| } else { |
| const FULL = 1 << nB; |
| let dp = new Float64Array(FULL).fill(-1); dp[0] = 0; |
| const choice = []; |
| for (let i = 0; i < nA; i++) { |
| const ndp = new Float64Array(FULL).fill(-1); |
| const ch = new Int8Array(FULL).fill(-2); |
| for (let mask = 0; mask < FULL; mask++) { |
| if (dp[mask] < 0) continue; |
| if (dp[mask] > ndp[mask]) { ndp[mask] = dp[mask]; ch[mask] = -1; } |
| for (let j = 0; j < nB; j++) { |
| if (mask & (1 << j) || ov[i][j] <= 0) continue; |
| const nm = mask | (1 << j), v = dp[mask] + ov[i][j]; |
| if (v > ndp[nm]) { ndp[nm] = v; ch[nm] = j; } |
| } |
| } |
| dp = ndp; choice.push(ch); |
| } |
| let best = 0; |
| for (let m = 0; m < FULL; m++) if (dp[m] > dp[best]) best = m; |
| let mask = best; |
| for (let i = nA - 1; i >= 0; i--) { |
| const j = choice[i][mask]; |
| if (j >= 0) { pairs.push([i, j]); mask ^= 1 << j; } |
| } |
| } |
| if (flip) pairs = pairs.map(([i, j]) => [j, i]); |
| return pairs; |
| } |
| |
| function computeMapping() { |
| const A = speakerList('a').sort(natCmp), B = speakerList('b').sort(natCmp); |
| const ov = A.map(() => B.map(() => 0)); |
| const bBySpk = new Map(B.map((s, j) => [s, j])); |
| const aBySpk = new Map(A.map((s, i) => [s, i])); |
| const bSegs = meta.files.b.segments; |
| for (const sa of meta.files.a.segments) { |
| const i = aBySpk.get(sa.speaker); |
| for (const sb of bSegs) { |
| const o = Math.min(sa.end, sb.end) - Math.max(sa.start, sb.start); |
| if (o > 0) ov[i][bBySpk.get(sb.speaker)] += o; |
| } |
| } |
| const idx = bestPairs(ov, A.length, B.length); |
| idx.sort((p, q) => ov[q[0]][q[1]] - ov[p[0]][p[1]]); // strongest first |
| mapping = {pairs: idx.map(([i, j]) => ({a: A[i], b: B[j]})), |
| colorOf: new Map(), nextColor: 0}; |
| mapping.pairs.forEach((p, k) => { |
| mapping.colorOf.set('a|' + p.a, k); |
| mapping.colorOf.set('b|' + p.b, k); |
| }); |
| mapping.nextColor = mapping.pairs.length; |
| for (const file of ['a', 'b']) |
| for (const spk of speakerList(file).sort(natCmp)) { |
| const key = file + '|' + spk; |
| if (!mapping.colorOf.has(key)) |
| mapping.colorOf.set(key, mapping.nextColor++); |
| } |
| } |
| |
| function colorFor(file, spk) { |
| const key = file + '|' + spk; |
| if (!mapping.colorOf.has(key)) |
| mapping.colorOf.set(key, mapping.nextColor++); |
| return PALETTE[mapping.colorOf.get(key) % PALETTE.length]; |
| } |
| function pairedWith(file, spk) { |
| for (const p of mapping.pairs) |
| if (p[file] === spk) return p[file === 'a' ? 'b' : 'a']; |
| return null; |
| } |
| function mappedId(file, spk) { |
| const k = mapping.pairs.findIndex(p => p[file] === spk); |
| return k >= 0 ? 'P' + k : file.toUpperCase() + '#' + spk; |
| } |
| function laneOrder(file) { |
| const spks = new Set(speakerList(file)); |
| const paired = mapping.pairs.map(p => p[file]).filter(s => spks.has(s)); |
| const rest = [...spks].filter(s => !paired.includes(s)).sort(natCmp); |
| return [...paired, ...rest]; |
| } |
| |
| /* ---------- diff computation ---------- */ |
| |
| function computeDiff() { |
| const bounds = new Set(); |
| const evts = {a: [], b: []}; |
| for (const file of ['a', 'b']) |
| for (const s of meta.files[file].segments) { |
| bounds.add(s.start); bounds.add(s.end); |
| evts[file].push([s.start, 1, s.speaker], [s.end, -1, s.speaker]); |
| } |
| const ts = [...bounds].sort((x, y) => x - y); |
| for (const file of ['a', 'b']) |
| evts[file].sort((x, y) => x[0] - y[0] || x[1] - y[1]); |
| const act = {a: new Map(), b: new Map()}; |
| const ptr = {a: 0, b: 0}; |
| const raw = []; |
| for (let k = 0; k + 1 < ts.length; k++) { |
| const t0 = ts[k], t1 = ts[k + 1]; |
| for (const file of ['a', 'b']) { |
| const e = evts[file], m = act[file]; |
| while (ptr[file] < e.length && e[ptr[file]][0] <= t0 + 1e-9) { |
| const [, d, spk] = e[ptr[file]++]; |
| m.set(spk, (m.get(spk) || 0) + d); |
| if (m.get(spk) <= 0) m.delete(spk); |
| } |
| } |
| const aSpk = [...act.a.keys()], bSpk = [...act.b.keys()]; |
| if (!aSpk.length && !bSpk.length) continue; |
| const sa = aSpk.map(s => mappedId('a', s)).sort().join(','); |
| const sb = bSpk.map(s => mappedId('b', s)).sort().join(','); |
| const cat = sa === sb ? 'same' : !aSpk.length ? 'bonly' |
| : !bSpk.length ? 'aonly' : 'mismatch'; |
| raw.push({t0, t1, cat, sa, sb, |
| aSpk: aSpk.sort(natCmp), bSpk: bSpk.sort(natCmp)}); |
| } |
| // merge contiguous regions with identical category and speaker sets |
| const merged = []; |
| for (const r of raw) { |
| const last = merged[merged.length - 1]; |
| if (last && last.cat === r.cat && last.sa === r.sa && last.sb === r.sb && |
| Math.abs(last.t1 - r.t0) < 1e-6) last.t1 = r.t1; |
| else merged.push({...r}); |
| } |
| diffStats = {union: 0, same: 0, aonly: 0, bonly: 0, mismatch: 0}; |
| for (const r of merged) { |
| const d = r.t1 - r.t0; |
| diffStats.union += d; |
| diffStats[r.cat] += d; |
| } |
| diffRegions = merged.filter(r => r.cat !== 'same'); |
| renderStats(); |
| } |
| |
| function renderStats() { |
| const s = diffStats; |
| const pct = s.union ? (100 * s.same / s.union).toFixed(1) : '100.0'; |
| $('diffstats').innerHTML = |
| `一致 <b>${pct}%</b>(按语音时长)` + |
| `<span class="sw" style="background:var(--aonly)"></span>仅A ${s.aonly.toFixed(1)}s` + |
| `<span class="sw" style="background:var(--bonly)"></span>仅B ${s.bonly.toFixed(1)}s` + |
| `<span class="sw" style="background:var(--mismatch)"></span>不一致 ${s.mismatch.toFixed(1)}s`; |
| } |
| |
| /* ---------- rendering ---------- */ |
| |
| function render() { |
| const pps = pxPerSec(), width = Math.ceil(LABEL_W + dur * pps); |
| $('tracks').style.width = width + 'px'; |
| |
| const ruler = $('ruler'); |
| ruler.innerHTML = ''; |
| const mask = document.createElement('div'); |
| mask.className = 'gutter-mask'; |
| ruler.appendChild(mask); |
| const steps = [0.1,0.2,0.5,1,2,5,10,15,30,60,120,300,600,1200,1800,3600]; |
| const step = steps.find(s => s*pps >= 90) || 3600; |
| for (let t = 0; t <= dur; t += step) { |
| if (tX(t) + 60 > width) break; // skip ticks whose text would overflow |
| const d = document.createElement('div'); |
| d.className = 'tick'; |
| d.style.left = tX(t) + 'px'; |
| d.textContent = fmt(t); |
| ruler.appendChild(d); |
| } |
| |
| const lanes = $('lanes'); |
| lanes.innerHTML = ''; |
| buildPanel(lanes, 'a', pps); |
| buildDiffLane(lanes, pps); |
| buildPanel(lanes, 'b', pps); |
| updateSaveBtns(); |
| updateInfo(); |
| drawSel(); |
| movePlayhead(); |
| } |
| |
| function buildPanel(parent, file, pps) { |
| const f = meta.files[file]; |
| const sep = document.createElement('div'); |
| sep.className = 'panel-sep'; |
| const spkN = new Set(f.segments.map(s => s.speaker)).size; |
| sep.innerHTML = |
| `<span class="lane-label"><b>${file.toUpperCase()}</b>·${f.rttm_file}` + |
| ` · ${f.segments.length} 段 · ${spkN} 人 ` + |
| `<button data-addspk="${file}">＋新说话人</button></span>`; |
| parent.appendChild(sep); |
| |
| for (const spk of laneOrder(file)) { |
| const lane = document.createElement('div'); |
| lane.className = 'lane'; |
| lane.dataset.file = file; |
| lane.dataset.speaker = spk; |
| const color = colorFor(file, spk); |
| const segs = f.segments.filter(s => s.speaker === spk); |
| const partner = pairedWith(file, spk); |
| const label = document.createElement('span'); |
| label.className = 'lane-label'; |
| label.innerHTML = |
| `<span class="swatch" style="background:${color}"></span>${spk} ` + |
| `<span style="color:var(--dim)">(${segs.length}` + |
| (partner !== null ? ` ⇄ ${file === 'a' ? 'B' : 'A'}:${partner}` : '') + |
| `)</span> <button data-addseg title="把当前选区加为该说话人的段">+段</button>`; |
| lane.appendChild(label); |
| for (const s of segs) { |
| const d = document.createElement('div'); |
| d.className = 'seg'; |
| d.dataset.file = file; |
| d.dataset.segId = s.id; |
| if (selected && selected.file === file && selected.id === s.id) |
| d.classList.add('selected'); |
| d.style.left = tX(s.start) + 'px'; |
| d.style.width = Math.max(2, (s.end-s.start)*pps) + 'px'; |
| d.style.background = colorFor(file, spk); |
| d.title = `${file.toUpperCase()}:${spk}\\n${fmt(s.start)} → ${fmt(s.end)}` + |
| ` (${(s.end-s.start).toFixed(2)}s)`; |
| lane.appendChild(d); |
| } |
| parent.appendChild(lane); |
| } |
| } |
| |
| function buildDiffLane(parent, pps) { |
| const lane = document.createElement('div'); |
| lane.className = 'difflane'; |
| const minDiff = parseFloat($('mindiff').value) || 0; |
| const shown = diffRegions.filter(r => r.t1 - r.t0 >= minDiff); |
| lane.innerHTML = `<span class="lane-label">差异 ` + |
| `<span style="color:var(--dim)">(${shown.length})</span></span>`; |
| for (const r of shown) { |
| const d = document.createElement('div'); |
| d.className = 'diffseg'; |
| d.dataset.t0 = r.t0; |
| d.dataset.t1 = r.t1; |
| d.style.left = tX(r.t0) + 'px'; |
| d.style.width = Math.max(2, (r.t1-r.t0)*pps) + 'px'; |
| d.style.background = CATCOLOR[r.cat]; |
| d.title = `${CATNAME[r.cat]} ${fmt(r.t0)} → ${fmt(r.t1)}` + |
| ` (${(r.t1-r.t0).toFixed(2)}s)\\n` + |
| `A: ${r.aSpk.join(', ') || '-'}\\nB: ${r.bSpk.join(', ') || '-'}`; |
| lane.appendChild(d); |
| } |
| parent.appendChild(lane); |
| } |
| |
| function updateInfo() { |
| $('rowinfo').textContent = `时长 ${fmt(dur)}`; |
| } |
| function updateSaveBtns() { |
| for (const file of ['a', 'b']) { |
| const b = $('save' + file); |
| b.textContent = `保存${file.toUpperCase()} → ${meta.files[file].out_file}` + |
| (dirty[file] ? ' *' : ''); |
| b.classList.toggle('dirty', dirty[file]); |
| } |
| } |
| |
| /* ---------- selection & playback (interval) ---------- */ |
| |
| function setSel(a, b, keepInputs) { |
| if (b < a) [a, b] = [b, a]; |
| sel = {start: a, end: b}; |
| $('playsel').disabled = $('clearsel').disabled = false; |
| $('selinfo').innerHTML = |
| `选区 <b>${fmt(a)}</b> → <b>${fmt(b)}</b> (${(b-a).toFixed(2)}s)`; |
| if (!keepInputs) { |
| $('selstart').value = a.toFixed(3); |
| $('selend').value = b.toFixed(3); |
| } |
| drawSel(); |
| } |
| function clearSel() { |
| sel = null; |
| $('playsel').disabled = $('clearsel').disabled = true; |
| $('selstart').value = $('selend').value = ''; |
| $('selinfo').textContent = '拖动空白选择区间;单击色块选中编辑'; |
| drawSel(); |
| } |
| function parseTime(str) { |
| str = str.trim(); |
| if (!str) return null; |
| const parts = str.split(':'); |
| if (parts.some(p => p.trim() === '' || isNaN(p))) return null; |
| return parts.reduce((t, p) => t * 60 + parseFloat(p), 0); |
| } |
| function applyManualSel() { |
| const a = parseTime($('selstart').value); |
| const b = parseTime($('selend').value); |
| if (a === null || b === null || a < 0 || b <= a || a >= dur) { |
| $('selinfo').innerHTML = '<span style="color:#ff7070">无效区间:' + |
| '支持 秒 或 分:秒 格式,需满足 0 ≤ 起 < 止</span>'; |
| return; |
| } |
| setSel(a, Math.min(b, dur), true); |
| playSel(); |
| } |
| function drawSel() { |
| const box = $('selbox'); |
| if (!sel) { box.style.display = 'none'; return; } |
| box.style.display = 'block'; |
| box.style.left = tX(sel.start) + 'px'; |
| box.style.width = ((sel.end-sel.start)*pxPerSec()) + 'px'; |
| } |
| function playSel() { |
| if (!sel) return; |
| audio.currentTime = sel.start; |
| audio.play(); |
| } |
| audio.addEventListener('timeupdate', () => { |
| if (sel && !audio.paused && audio.currentTime >= sel.end) { |
| if ($('loop').checked) audio.currentTime = sel.start; |
| else audio.pause(); |
| } |
| }); |
| |
| function movePlayhead() { |
| $('playhead').style.left = tX(audio.currentTime) + 'px'; |
| } |
| let progScroll = false; |
| function followPlayhead(force) { |
| if (!$('follow').checked || !dur) return; |
| const outer = $('tracks-outer'); |
| if (outer.scrollWidth <= outer.clientWidth + 1) return; |
| const x = tX(audio.currentTime); |
| const lo = outer.scrollLeft + LABEL_W + 10; |
| const hi = outer.scrollLeft + outer.clientWidth - 40; |
| if (force || x < lo || x > hi) { |
| progScroll = true; |
| outer.scrollLeft = Math.max(0, |
| x - LABEL_W - (outer.clientWidth - LABEL_W) * 0.15); |
| } |
| } |
| $('tracks-outer').addEventListener('scroll', () => { |
| if (progScroll) { progScroll = false; return; } |
| if (!audio.paused) $('follow').checked = false; |
| }); |
| $('follow').onchange = () => followPlayhead(true); |
| audio.addEventListener('seeked', () => followPlayhead(true)); |
| (function raf() { |
| movePlayhead(); |
| if (!audio.paused) followPlayhead(); |
| requestAnimationFrame(raf); |
| })(); |
| |
| /* ---------- editing ---------- */ |
| |
| function pushUndo(file) { |
| const f = meta.files[file]; |
| undoStack[file].push(JSON.stringify( |
| {segments: f.segments, extraSpeakers: [...f.extraSpeakers]})); |
| if (undoStack[file].length > 200) undoStack[file].shift(); |
| redoStack[file].length = 0; |
| } |
| function restore(file, snap) { |
| const f = meta.files[file]; |
| const o = JSON.parse(snap); |
| f.segments = o.segments; |
| f.extraSpeakers = new Set(o.extraSpeakers); |
| } |
| function snapshot(file) { |
| const f = meta.files[file]; |
| return JSON.stringify( |
| {segments: f.segments, extraSpeakers: [...f.extraSpeakers]}); |
| } |
| function undo(file) { |
| if (!undoStack[file].length) return; |
| redoStack[file].push(snapshot(file)); |
| restore(file, undoStack[file].pop()); |
| afterEdit(file, true); |
| } |
| function redo(file) { |
| if (!redoStack[file].length) return; |
| undoStack[file].push(snapshot(file)); |
| restore(file, redoStack[file].pop()); |
| afterEdit(file, true); |
| } |
| // after any data mutation: mark dirty, recompute diff, redraw |
| function afterEdit(file, checkSelection) { |
| dirty[file] = true; |
| if (checkSelection && selected && selected.file === file && |
| !findSeg(file, selected.id)) deselectSeg(); |
| computeDiff(); |
| render(); |
| refreshEditbar(); |
| } |
| function lastEditedFile() { |
| return selected ? selected.file : null; |
| } |
| |
| function selectSeg(file, id) { |
| selected = {file, id}; |
| document.querySelectorAll('.seg.selected') |
| .forEach(e => e.classList.remove('selected')); |
| const el = document.querySelector( |
| `.seg[data-file="${file}"][data-seg-id="${id}"]`); |
| if (el) el.classList.add('selected'); |
| refreshEditbar(); |
| } |
| function deselectSeg() { |
| selected = null; |
| document.querySelectorAll('.seg.selected') |
| .forEach(e => e.classList.remove('selected')); |
| refreshEditbar(); |
| } |
| function refreshEditbar() { |
| const bar = $('editbar'); |
| if (!selected) { bar.style.display = 'none'; return; } |
| const s = findSeg(selected.file, selected.id); |
| if (!s) { bar.style.display = 'none'; return; } |
| bar.style.display = 'flex'; |
| $('ebtitle').textContent = |
| `${selected.file.toUpperCase()} · ${s.speaker}`; |
| $('ebspk').value = s.speaker; |
| $('ebstart').value = s.start.toFixed(3); |
| $('ebend').value = s.end.toFixed(3); |
| $('ebdur').textContent = `(${(s.end - s.start).toFixed(2)}s)`; |
| const dl = $('spklist'); |
| dl.innerHTML = ''; |
| for (const spk of laneOrder(selected.file)) { |
| const o = document.createElement('option'); |
| o.value = spk; |
| dl.appendChild(o); |
| } |
| } |
| function applyEditbar() { |
| if (!selected) return; |
| const s = findSeg(selected.file, selected.id); |
| const start = parseTime($('ebstart').value); |
| const end = parseTime($('ebend').value); |
| const spk = $('ebspk').value.trim(); |
| if (start === null || end === null || !spk || |
| start < 0 || end <= start || start >= dur) { |
| $('ebdur').textContent = '(无效输入)'; |
| return; |
| } |
| pushUndo(selected.file); |
| s.start = start; s.end = Math.min(end, dur); s.speaker = spk; |
| afterEdit(selected.file); |
| } |
| function splitSelected() { |
| if (!selected) return; |
| const s = findSeg(selected.file, selected.id); |
| const t = audio.currentTime; |
| if (t <= s.start + 0.02 || t >= s.end - 0.02) { |
| $('ebdur').textContent = '(播放头不在段内,无法拆分)'; |
| return; |
| } |
| pushUndo(selected.file); |
| const right = {id: nextId++, start: t, end: s.end, speaker: s.speaker}; |
| s.end = t; |
| meta.files[selected.file].segments.push(right); |
| afterEdit(selected.file); |
| } |
| function deleteSelected() { |
| if (!selected) return; |
| const f = meta.files[selected.file]; |
| pushUndo(selected.file); |
| f.segments = f.segments.filter(s => s.id !== selected.id); |
| const file = selected.file; |
| deselectSeg(); |
| afterEdit(file); |
| } |
| function addSegFromSel(file, spk) { |
| if (!sel) { |
| $('selinfo').innerHTML = |
| '<span style="color:#ff7070">先拖动选择一个区间,再点 +段</span>'; |
| return; |
| } |
| pushUndo(file); |
| const s = {id: nextId++, start: sel.start, end: sel.end, speaker: spk}; |
| meta.files[file].segments.push(s); |
| afterEdit(file); |
| selectSeg(file, s.id); |
| } |
| function addSpeaker(file) { |
| const name = prompt('新说话人标签(仅用于本页;保存时无段的说话人不会写入 RTTM):'); |
| if (!name || !name.trim()) return; |
| meta.files[file].extraSpeakers.add(name.trim()); |
| render(); |
| } |
| |
| /* ---------- mouse interactions on tracks ---------- */ |
| |
| const tracksEl = $('tracks'); |
| tracksEl.addEventListener('mousedown', ev => { |
| const segEl = ev.target.closest('.seg'); |
| if (segEl) { |
| const file = segEl.dataset.file, id = +segEl.dataset.segId; |
| const r = segEl.getBoundingClientRect(); |
| const x = ev.clientX - r.left; |
| const edge = Math.min(6, r.width / 3); |
| const mode = r.width >= 12 && x < edge ? 'resize-l' |
| : r.width >= 12 && x > r.width - edge ? 'resize-r' : 'move'; |
| const s = findSeg(file, id); |
| dragging = {mode, file, id, el: segEl, moved: false, pushed: false, |
| grabOffset: xToTime(ev.clientX) - s.start}; |
| ev.preventDefault(); |
| return; |
| } |
| const diffEl = ev.target.closest('.diffseg'); |
| if (diffEl) { |
| dragging = {mode: 'select', anchor: xToTime(ev.clientX), moved: false, |
| diffEl}; |
| ev.preventDefault(); |
| return; |
| } |
| const lane = ev.target.closest('.lane'); |
| if (ev.altKey && lane) { |
| dragging = {mode: 'create', file: lane.dataset.file, |
| spk: lane.dataset.speaker, lane, |
| anchor: xToTime(ev.clientX), t0: null, t1: null, |
| el: null, moved: false}; |
| ev.preventDefault(); |
| return; |
| } |
| dragging = {mode: 'select', anchor: xToTime(ev.clientX), moved: false}; |
| ev.preventDefault(); |
| }); |
| |
| window.addEventListener('mousemove', ev => { |
| if (!dragging) return; |
| const t = xToTime(ev.clientX); |
| const pps = pxPerSec(); |
| if (dragging.mode === 'select') { |
| if (Math.abs(t - dragging.anchor) * pps > 3) { |
| dragging.moved = true; |
| setSel(dragging.anchor, t); |
| } |
| } else if (dragging.mode === 'create') { |
| if (Math.abs(t - dragging.anchor) * pps > 3) { |
| dragging.moved = true; |
| dragging.t0 = Math.min(dragging.anchor, t); |
| dragging.t1 = Math.max(dragging.anchor, t); |
| if (!dragging.el) { |
| dragging.el = document.createElement('div'); |
| dragging.el.className = 'seg'; |
| dragging.el.style.background = |
| colorFor(dragging.file, dragging.spk); |
| dragging.el.style.opacity = '0.6'; |
| dragging.lane.appendChild(dragging.el); |
| } |
| dragging.el.style.left = tX(dragging.t0) + 'px'; |
| dragging.el.style.width = Math.max(2, (dragging.t1-dragging.t0)*pps) + 'px'; |
| } |
| } else { // move / resize |
| const s = findSeg(dragging.file, dragging.id); |
| if (!s) { dragging = null; return; } |
| if (!dragging.pushed) { pushUndo(dragging.file); dragging.pushed = true; } |
| dragging.moved = true; |
| if (dragging.mode === 'move') { |
| const len = s.end - s.start; |
| const ns = Math.min(Math.max(t - dragging.grabOffset, 0), dur - len); |
| s.start = ns; s.end = ns + len; |
| } else if (dragging.mode === 'resize-l') { |
| s.start = Math.min(Math.max(t, 0), s.end - 0.02); |
| } else { |
| s.end = Math.max(Math.min(t, dur), s.start + 0.02); |
| } |
| dragging.el.style.left = tX(s.start) + 'px'; |
| dragging.el.style.width = Math.max(2, (s.end-s.start)*pps) + 'px'; |
| if (selected && selected.file === dragging.file && |
| selected.id === dragging.id) { |
| $('ebstart').value = s.start.toFixed(3); |
| $('ebend').value = s.end.toFixed(3); |
| $('ebdur').textContent = `(${(s.end - s.start).toFixed(2)}s)`; |
| } |
| } |
| }); |
| |
| window.addEventListener('mouseup', ev => { |
| if (!dragging) return; |
| const d = dragging; |
| dragging = null; |
| if (d.mode === 'select') { |
| if (!d.moved) { |
| if (d.diffEl) { // click on a diff region: select it and play |
| setSel(+d.diffEl.dataset.t0, +d.diffEl.dataset.t1); |
| playSel(); |
| } else { |
| audio.currentTime = xToTime(ev.clientX); |
| } |
| } |
| } else if (d.mode === 'create') { |
| if (d.el) d.el.remove(); |
| if (d.moved && d.t1 - d.t0 >= 0.05) { |
| pushUndo(d.file); |
| const s = {id: nextId++, start: d.t0, end: d.t1, speaker: d.spk}; |
| meta.files[d.file].segments.push(s); |
| afterEdit(d.file); |
| selectSeg(d.file, s.id); |
| } |
| } else { // move / resize finished (or plain click on a segment) |
| if (d.moved) { |
| afterEdit(d.file); |
| selectSeg(d.file, d.id); |
| } else { |
| selectSeg(d.file, d.id); |
| } |
| } |
| }); |
| |
| tracksEl.addEventListener('dblclick', ev => { |
| const segEl = ev.target.closest('.seg'); |
| if (!segEl) return; |
| const s = findSeg(segEl.dataset.file, +segEl.dataset.segId); |
| if (s) { setSel(s.start, s.end); playSel(); } |
| }); |
| |
| // lane-label "+seg" / panel "+speaker" buttons (delegated) |
| $('lanes').addEventListener('click', ev => { |
| const t = ev.target; |
| if (t.dataset && 'addseg' in t.dataset) { |
| const lane = t.closest('.lane'); |
| addSegFromSel(lane.dataset.file, lane.dataset.speaker); |
| } else if (t.dataset && t.dataset.addspk) { |
| addSpeaker(t.dataset.addspk); |
| } |
| }); |
| |
| /* ---------- save ---------- */ |
| |
| async function save(which) { |
| const f = meta.files[which]; |
| $('savemsg').textContent = '保存中…'; |
| try { |
| const r = await fetch('/api/save', { |
| method: 'POST', |
| headers: {'Content-Type': 'application/json'}, |
| body: JSON.stringify({which, segments: f.segments.map( |
| ({start, end, speaker}) => ({start, end, speaker}))}), |
| }); |
| if (!r.ok) throw new Error(await r.text()); |
| const res = await r.json(); |
| dirty[which] = false; |
| updateSaveBtns(); |
| $('savemsg').textContent = `已保存 ${res.n} 段 → ${res.path}`; |
| } catch (e) { |
| $('savemsg').textContent = ''; |
| $('err').textContent = '保存失败: ' + e; |
| $('err').style.display = 'block'; |
| } |
| } |
| $('savea').onclick = () => save('a'); |
| $('saveb').onclick = () => save('b'); |
| window.addEventListener('beforeunload', ev => { |
| if (dirty.a || dirty.b) { ev.preventDefault(); ev.returnValue = ''; } |
| }); |
| |
| /* ---------- top-level controls & keys ---------- */ |
| |
| $('zoom').oninput = () => { |
| zoomFactor = Math.pow(2, $('zoom').value / 12.5); // 1x .. 256x |
| $('zoomval').textContent = zoomFactor < 10 ? |
| zoomFactor.toFixed(1)+'×' : Math.round(zoomFactor)+'×'; |
| render(); |
| }; |
| $('playsel').onclick = playSel; |
| $('clearsel').onclick = clearSel; |
| $('applysel').onclick = applyManualSel; |
| $('mindiff').oninput = () => render(); |
| $('remap').onclick = () => { computeMapping(); computeDiff(); render(); }; |
| $('ebapply').onclick = applyEditbar; |
| $('ebplay').onclick = () => { |
| if (!selected) return; |
| const s = findSeg(selected.file, selected.id); |
| if (s) { setSel(s.start, s.end); playSel(); } |
| }; |
| $('ebsplit').onclick = splitSelected; |
| $('ebdel').onclick = deleteSelected; |
| $('ebclose').onclick = deselectSeg; |
| ['selstart', 'selend'].forEach(id => $(id).addEventListener('keydown', |
| ev => { if (ev.key === 'Enter') applyManualSel(); })); |
| ['ebspk', 'ebstart', 'ebend'].forEach(id => $(id).addEventListener('keydown', |
| ev => { if (ev.key === 'Enter') applyEditbar(); })); |
| |
| document.addEventListener('keydown', ev => { |
| const typing = ev.target.tagName === 'INPUT' && |
| ev.target.type !== 'checkbox' && |
| ev.target.type !== 'range'; |
| if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'z') { |
| ev.preventDefault(); |
| const f = lastEditedFile() || |
| (undoStack.a.length ? 'a' : undoStack.b.length ? 'b' : null); |
| if (f) ev.shiftKey ? redo(f) : undo(f); |
| return; |
| } |
| if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'y') { |
| ev.preventDefault(); |
| const f = lastEditedFile() || |
| (redoStack.a.length ? 'a' : redoStack.b.length ? 'b' : null); |
| if (f) redo(f); |
| return; |
| } |
| if (typing) return; |
| const jump = ev.shiftKey ? 0.5 : 5; |
| if (ev.key === 'ArrowLeft') |
| audio.currentTime = Math.max(0, audio.currentTime - jump); |
| else if (ev.key === 'ArrowRight') |
| audio.currentTime = Math.min(dur, audio.currentTime + jump); |
| else if (ev.key === 'Escape') selected ? deselectSeg() : clearSel(); |
| else if (ev.key === 'Delete' || ev.key === 'Backspace') deleteSelected(); |
| else if (ev.key.toLowerCase() === 's') splitSelected(); |
| else if (ev.key === ' ') { ev.preventDefault(); |
| audio.paused ? audio.play() : audio.pause(); } |
| }); |
| window.addEventListener('resize', render); |
| |
| // non-WAV audio: the server may only estimate the duration from the last |
| // segment end, so refine it once the browser has decoded the metadata |
| audio.addEventListener('loadedmetadata', () => { |
| if (isFinite(audio.duration) && Math.abs(audio.duration - dur) > 0.05) { |
| dur = audio.duration; |
| render(); |
| } |
| }); |
| |
| async function load() { |
| $('err').style.display = 'none'; |
| let m; |
| try { |
| const r = await fetch('/api/meta'); |
| if (!r.ok) throw new Error(await r.text()); |
| m = await r.json(); |
| } catch (e) { |
| $('err').textContent = '加载失败: ' + e; |
| $('err').style.display = 'block'; |
| return; |
| } |
| meta = {audio_file: m.audio_file, duration: m.duration, |
| files: {a: m.a, b: m.b}}; |
| for (const file of ['a', 'b']) { |
| const f = meta.files[file]; |
| f.extraSpeakers = new Set(); |
| f.segments.forEach(s => { s.id = nextId++; }); |
| } |
| dur = meta.duration; |
| clearSel(); |
| audio.src = '/api/audio'; |
| $('fname').textContent = |
| `${m.audio_file} · A=${m.a.rttm_file} · B=${m.b.rttm_file}`; |
| document.title = '双 RTTM 对比编辑器 – ' + m.audio_file; |
| computeMapping(); |
| computeDiff(); |
| render(); |
| } |
| |
| load(); |
| </script> |
| </body> |
| </html> |
| """ |
|
|
|
|
| class Handler(BaseHTTPRequestHandler): |
| audio_bytes = b"" |
| ctype = "audio/x-wav" |
| meta = {} |
| files = {} |
|
|
| def log_message(self, *args): |
| pass |
|
|
| def _send(self, code, body, ctype="application/json", extra=None): |
| self.send_response(code) |
| self.send_header("Content-Type", ctype) |
| self.send_header("Content-Length", str(len(body))) |
| for k, v in (extra or {}).items(): |
| self.send_header(k, v) |
| self.end_headers() |
| self.wfile.write(body) |
|
|
| def do_GET(self): |
| try: |
| self._route() |
| except BrokenPipeError: |
| pass |
| except Exception as e: |
| self._send(500, str(e).encode(), "text/plain; charset=utf-8") |
|
|
| def do_POST(self): |
| try: |
| if self.path == "/api/save": |
| length = int(self.headers.get("Content-Length", 0)) |
| payload = json.loads(self.rfile.read(length)) |
| self._save(payload) |
| else: |
| self._send(404, b"not found", "text/plain") |
| except BrokenPipeError: |
| pass |
| except Exception as e: |
| self._send(500, str(e).encode(), "text/plain; charset=utf-8") |
|
|
| def _save(self, payload): |
| which = payload.get("which") |
| if which not in self.files: |
| raise ValueError(f"unknown rttm key: {which!r}") |
| info = self.files[which] |
| segs = sorted(payload["segments"], key=lambda s: float(s["start"])) |
| lines = [] |
| for s in segs: |
| start, end = float(s["start"]), float(s["end"]) |
| spk = re.sub(r"\s+", "_", str(s["speaker"]).strip()) |
| if not spk: |
| raise ValueError("empty speaker label") |
| if end <= start or start < 0: |
| raise ValueError(f"invalid segment [{start}, {end}]") |
| lines.append(f"SPEAKER {info['fid']} {info['chan']} " |
| f"{start:.3f} {end - start:.3f} " |
| f"<NA> <NA> {spk} <NA> <NA>\n") |
| with open(info["out_path"], "w", encoding="utf-8") as f: |
| f.writelines(lines) |
| self._send(200, json.dumps( |
| {"path": info["out_path"], "n": len(lines)}).encode()) |
|
|
| def _route(self): |
| if self.path in ("/", "/index.html"): |
| self._send(200, PAGE.encode(), "text/html; charset=utf-8") |
| elif self.path == "/api/meta": |
| self._send(200, json.dumps(self.meta).encode()) |
| elif self.path == "/api/audio": |
| self._serve_audio(self.audio_bytes, self.ctype) |
| else: |
| self._send(404, b"not found", "text/plain") |
|
|
| def _serve_audio(self, data, ctype): |
| """Serve audio bytes with Range support so the player can seek.""" |
| rng = self.headers.get("Range") |
| total = len(data) |
| if rng and (m := re.fullmatch(r"bytes=(\d*)-(\d*)", rng.strip())): |
| start = int(m.group(1)) if m.group(1) else 0 |
| end = int(m.group(2)) if m.group(2) else total - 1 |
| end = min(end, total - 1) |
| if start > end: |
| self._send(416, b"", ctype, |
| {"Content-Range": f"bytes */{total}"}) |
| return |
| chunk = data[start:end + 1] |
| self._send(206, chunk, ctype, { |
| "Content-Range": f"bytes {start}-{end}/{total}", |
| "Accept-Ranges": "bytes"}) |
| else: |
| self._send(200, data, ctype, {"Accept-Ranges": "bytes"}) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description=__doc__.split("\n")[0]) |
| ap.add_argument("audio", help="path to the audio file (wav/mp3/...)") |
| ap.add_argument("rttm_a", help="path to the first RTTM file (panel A)") |
| ap.add_argument("rttm_b", help="path to the second RTTM file (panel B)") |
| ap.add_argument("--port", type=int, default=8766) |
| ap.add_argument("--host", default="127.0.0.1") |
| args = ap.parse_args() |
|
|
| data, ctype, duration = load_audio(args.audio) |
| file_meta, files = {}, {} |
| for key, path in (("a", args.rttm_a), ("b", args.rttm_b)): |
| segments, fid, chan = parse_rttm(path) |
| out_path = os.path.splitext(path)[0] + "_new.rttm" |
| files[key] = {"fid": fid or os.path.splitext( |
| os.path.basename(args.audio))[0], |
| "chan": chan or "1", "out_path": out_path} |
| file_meta[key] = {"rttm_file": os.path.basename(path), |
| "out_file": os.path.basename(out_path), |
| "segments": segments} |
| if duration is None: |
| duration = max(s["end"] for k in file_meta |
| for s in file_meta[k]["segments"]) |
|
|
| Handler.audio_bytes = data |
| Handler.ctype = ctype |
| Handler.files = files |
| Handler.meta = { |
| "audio_file": os.path.basename(args.audio), |
| "duration": duration, |
| "a": file_meta["a"], |
| "b": file_meta["b"], |
| } |
| srv = ThreadingHTTPServer((args.host, args.port), Handler) |
| print(f"Serving {args.audio}\n A: {args.rttm_a} " |
| f"({len(file_meta['a']['segments'])} segments)\n B: {args.rttm_b} " |
| f"({len(file_meta['b']['segments'])} segments)\n" |
| f"at http://{args.host}:{args.port}\n" |
| f"Edits save to {files['a']['out_path']} / {files['b']['out_path']}") |
| try: |
| srv.serve_forever() |
| except KeyboardInterrupt: |
| pass |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
