From b2b0f8d2b2bba17bf90957597457cf8471711173 Mon Sep 17 00:00:00 2001 From: kicer Date: Sat, 24 Oct 2026 20:11:25 +0800 Subject: [PATCH] =?UTF-8?q?=E8=AF=AD=E9=9F=B3=E8=BE=93=E5=85=A5=E6=94=B9?= =?UTF-8?q?=E4=B8=BA=E6=B5=81=E5=BC=8F=E6=96=AD=E5=8F=A5=EF=BC=8C=E6=9C=8D?= =?UTF-8?q?=E5=8A=A1=E7=AB=AF=E5=8F=AA=E5=81=9A=E8=B6=85=E9=95=BF=E5=85=9C?= =?UTF-8?q?=E5=BA=95=E5=88=87=E5=88=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 壳推 16k/单声道/16bit PCM 分片(onNativeVoiceChunk,~100ms 一片), 页面自己判停顿(≥0.5s 静音)断句、逐段串行上传;松手只 flush 剩下的话, 全部结果到齐后一次性写进输入框并自动发送 - 纯静音的尾巴不再上传(否则只会换来一次「没有可识别人声」) - 删除 onNativeVoiceResult / onNativeVoiceAmp:声波改由页面用 PCM 峰值驱动 - 服务端不再逢停顿就切:≤25s 直接一次请求、不跑 silencedetect; >25s 才在距上限最后 6s 的窗口里挑停顿中点,挑不到硬切,段数 ≈ 时长/25 (去掉 ASR_MAX_SEGMENTS 的 20 段退化分支) - 上游 200 + 空 text 改判 400(这是「这段没人声」的正常结果,不再打堆栈) - docs/voice-input.md 按新契约整篇重写(含 AudioRecord 参考骨架) --- app/server/public/js/voice.js | 246 +++++++++++++++++----- docs/voice-input.md | 371 ++++++++++++++++------------------ mcp/asr/README.md | 18 +- mcp/asr/src/server.js | 156 +++++++++++--- 4 files changed, 513 insertions(+), 278 deletions(-) diff --git a/app/server/public/js/voice.js b/app/server/public/js/voice.js index b2930b1..d512f36 100644 --- a/app/server/public/js/voice.js +++ b/app/server/public/js/voice.js @@ -8,10 +8,11 @@ // · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送** // · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘) // -// 录音在客户端:套壳原生桥(http 页面也能用)或 HTTPS 下的 MediaRecorder; -// 转写在服务端 mcp_asr(经 core 的 /api/asr 中转)。 -// 电平:浏览器用 AnalyserNode 算 RMS;套壳上报 onNativeVoiceAmp(原始 getMaxAmplitude)。 -// 归一化/门限/平滑全部在页面侧做,壳不做任何换算。 +// 录音在客户端,两条路: +// · 套壳原生桥(http 页面也能用):壳把 16k/单声道 PCM 以 ~100ms 分片推给页面,页面自己判停顿、 +// 自己切段、逐段上传——**大部分识别在说话过程中就做完了**,松手只等最后一段。 +// · 浏览器(需 HTTPS):MediaRecorder 整段录,松手后整体上传(实时版下一阶段再做)。 +// 电平:两者都在页面侧算(套壳用 PCM 峰值,浏览器用 AnalyserNode 的 RMS),壳不做任何换算。 // // 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。 @@ -30,9 +31,10 @@ const webOk = !!(window.isSecureContext && navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function' && window.MediaRecorder); - const MAX_MS = 60000; // 单次录音上限 + const MAX_MS = 180000; // 单次录音上限(流式上传后不再受 60s 限制) const MIN_MS = 500; // 短于这个时长按误触处理,不上传 const NO_RESULT_MS = 3000; // 松开后壳迟迟不回音频(比如还在等权限)→ 复位 + const FLUSH_MS = 60000; // 松手后等尾段识别完的上限(超过就当失败) const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到) // 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子 @@ -59,12 +61,28 @@ let recordStartAt = 0; let stopTimer = null; let hardTimer = null; - let watchdog = null; let rec = null; let stream = null; let chunks = []; let mime = ''; + // 原生流式:壳推 PCM 分片,页面 VAD 断句后逐段上传 + let pcmRate = 16000; // 壳推上来的采样率(契约要求 16k) + let segChunks = []; // 当前段的 PCM 分片(Int16Array) + let segLen = 0; // 当前段总采样数 + let silLen = 0; // 段尾连续静音采样数 + let textParts = []; // 各段识别结果(按顺序) + let chain = Promise.resolve(); // 串行上传链:保证拼接顺序 = 说话顺序 + let gen = 0; // 会话代号:取消/重录后迟到结果直接丢弃 + let streamOn = false; // 是否接受 PCM 分片 + let flushTimer = null; + + // VAD 参数(页面侧唯一一份:改完刷新页面即生效,不用重打 APK) + const VAD_SILENCE_DB = -42; // 低于这个音量算“没人说话”(正常说话峰值约 -10~-30dB) + const VAD_PAUSE_SEC = 0.5; // 连续静音这么久 → 断句(与壳无关) + const VAD_MIN_SPEECH_SEC = 0.3; // 一段短于这个 → 当噪声丢掉 + const VAD_MAX_SEG_SEC = 25; // 单段上限:连续说话没停顿就硬切(上游单次上限) + // 电平与渲染 let rafId = 0; let levelTarget = 0; @@ -135,7 +153,7 @@ } if (!animate) { - // 没有电平来源(壳没实现 onNativeVoiceAmp / AnalyserNode 不可用): + // 没有电平来源(壳没推 PCM / AnalyserNode 不可用): // 静默停在基线,不再空转(也绝不能假动) levelCur = 0; renderBars(0, false); @@ -206,9 +224,9 @@ pressing = false; pressY = 0; discard = false; + abortStream(); if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; } if (hardTimer) { clearTimeout(hardTimer); hardTimer = null; } - if (watchdog) { clearTimeout(watchdog); watchdog = null; } hold.classList.remove('recording'); setHoldText('按住 说话'); hideOverlay(); @@ -262,16 +280,16 @@ showOverlay(); if (native) { - // 原生侧即使要弹权限也先当「已开始」:松开时 stopVoice(),壳若还在等权限会忽略, - // 由 watchdog 兜底复位(只有首次授权那一次会遇到)。 + // 原生侧即使要弹权限也先当「已开始」:页面已经开始收分片,壳真开录后会推数据。 + // 首次授权那一次的分片要等用户点允许才会到,之前的静音不计入。 phase = 'recording'; recordStartAt = Date.now(); + gen++; // 新会话:让上一轮迟到的结果全部失效 + streamOn = true; + pcmRate = 16000; + clearSeg(); + textParts = []; stopTimer = setTimeout(finishHold, MAX_MS); - hardTimer = setTimeout(function () { - try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ } - resetUI(); - toast('录音超时'); - }, MAX_MS + NO_RESULT_MS); try { native.startVoice(); } catch (e) { @@ -352,6 +370,16 @@ stopMeter(); if (native) { + // 松手:把不足一个停顿的尾巴发走,然后等所有段回来。 + // 大部分段在说话过程中已经识别完了,这里通常只等最后一段。 + if (discard) { + abortStream(); + try { native.stopVoice(); } catch (_) { /* 已停 */ } + resetUI(); + toast('说话时间太短'); + return; + } + flushTail(); try { native.stopVoice(); } catch (e) { @@ -359,12 +387,7 @@ toast('结束录音失败:' + String((e && e.message) || e)); return; } - // 壳若因为权限弹窗没有真正开录,stopVoice() 会被忽略、结果不会回来 - watchdog = setTimeout(function () { - if (phase !== 'busy') return; - try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ } - resetUI(); - }, NO_RESULT_MS); + waitFlush(); return; } @@ -383,6 +406,7 @@ const r = rec; rec = null; chunks = []; + abortStream(); // 丢弃已发在途的结果,也不碰输入框 if (r) { r.onstop = null; r.onerror = null; } releaseStream(); resetUI(); @@ -479,42 +503,163 @@ window.addEventListener('pagehide', cancelHold); // ---------- 原生桥回调(契约见 docs/voice-input.md) ---------- - // 实时幅度:套壳每 ~100ms 上报一次 MediaRecorder.getMaxAmplitude() 的**原始值**(0~32767)。 - // 换算、门限、平滑全部在页面侧做——规则只存在这一份,壳不要做任何数学。 - function onNativeAmp(raw) { - if (!native) return; - const amp = Number(raw); - if (!isFinite(amp)) return; - lastRealLevelAt = Date.now(); - if (amp <= 0) { - levelTarget = 0; - } else { - const db = 20 * Math.log10(Math.min(amp, 32767) / 32767); - levelTarget = dbToLevel(db); - } - startLoop(); // 静默态下循环已停,下一帧数据到了再启 + // 壳每 ~100ms 推一片 16bit/单声道小端 PCM。采样率、分片大小、门限全部不在壳里算。 + function b64ToI16(b64) { + const bin = atob(String(b64 || '')); + const n = bin.length >> 1; + const out = new Int16Array(n); + for (let i = 0; i < n; i++) out[i] = (bin.charCodeAt(i * 2 + 1) << 8) | bin.charCodeAt(i * 2); + return out; } - window.onNativeVoiceAmp = onNativeAmp; - window.onNativeVoiceLevel = onNativeAmp; // 旧名兼容:同样按原始幅度解释 - window.onNativeVoiceResult = function (b64, mimeType) { - if (phase !== 'busy' && phase !== 'recording') return; - if (watchdog) { clearTimeout(watchdog); watchdog = null; } - if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; } - try { - const bin = atob(String(b64 || '')); - const arr = new Uint8Array(bin.length); - for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i); - upload(new Blob([arr], { type: mimeType || 'audio/mp4' })); - } catch (_) { - resetUI(); - toast('语音数据解析失败'); + // 这一片 PCM 的峰值电平(dBFS)。用峰值而不是 RMS:与原先 getMaxAmplitude 的尺度一致。 + function peakDb(arr) { + let peak = 0; + for (let i = 0; i < arr.length; i++) { + const v = arr[i] < 0 ? -arr[i] : arr[i]; + if (v > peak) peak = v; + } + return peak <= 0 ? -Infinity : 20 * Math.log10(peak / 32767); + } + + function encodeWav(samples, rate) { + const b = new ArrayBuffer(44 + samples.length * 2); + const v = new DataView(b); + const str = function (off, s) { for (let i = 0; i < s.length; i++) v.setUint8(off + i, s.charCodeAt(i)); }; + str(0, 'RIFF'); v.setUint32(4, 36 + samples.length * 2, true); str(8, 'WAVE'); + str(12, 'fmt '); v.setUint32(16, 16, true); + v.setUint16(20, 1, true); // PCM + v.setUint16(22, 1, true); // mono + v.setUint32(24, rate, true); // 采样率 + v.setUint32(28, rate * 2, true); // byte rate + v.setUint16(32, 2, true); v.setUint16(34, 16, true); + str(36, 'data'); v.setUint32(40, samples.length * 2, true); + for (let i = 0, o = 44; i < samples.length; i++, o += 2) v.setInt16(o, samples[i], true); + return new Blob([b], { type: 'audio/wav' }); + } + + // 从当前段取前 n 个采样(拼成一段连续 PCM) + function takeSeg(n) { + const out = new Int16Array(n); + let off = 0; + for (const c of segChunks) { + if (off >= n) break; + const k = Math.min(c.length, n - off); + out.set(k === c.length ? c : c.subarray(0, k), off); + off += k; + } + return out; + } + + function clearSeg() { segChunks = []; segLen = 0; silLen = 0; } + + // 把当前段的前 n 个采样作为一段发出去(太短当噪声丢掉)。 + // 注意:必须在 clearSeg() 之前调,takeSeg 要读 segChunks。 + function emitSegment(n) { + if (n < pcmRate * VAD_MIN_SPEECH_SEC) return; + emit(encodeWav(takeSeg(n), pcmRate)); + } + + // 串行上传:一段没回来不发下一段(2 vCPU 上并发只会互相拖慢,而且顺序也没法保证) + function emit(blob) { + const my = gen; + chain = chain.then(function () { + if (my !== gen) return; // 已取消/重录:不再发 + return req('POST', '/api/asr/transcribe', blob, true, 120000) + .then(function (r) { + if (my !== gen) return; + const t = String((r && r.text) || '').replace(/\s+/g, ' ').trim(); + if (t) textParts.push(t); + }) + .catch(function () { /* 单段失败不连坐,其余段照常出字 */ }); + }); + } + + // 拼接各段:中文直接相连;两侧都是西文字母/数字时补一个空格, + // 否则英文被切开后会粘成 "helloworld"。 + function joinText(parts) { + let out = ''; + for (const s of parts) { + if (!s) continue; + if (out && /[A-Za-z0-9]$/.test(out) && /^[A-Za-z0-9]/.test(s)) out += ' '; + out += s; + } + return out; + } + + // 丢弃本轮的一切(段缓冲 + 已发在途结果):取消 / 误触 / 超时都走这里 + function abortStream() { + streamOn = false; + clearSeg(); + textParts = []; + gen++; + if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; } + } + + window.onNativeVoiceChunk = function (b64, rate) { + if (!native || !streamOn || phase !== 'recording') return; + const r = Number(rate); + if (r > 0 && r !== pcmRate) pcmRate = r; + const pcm = b64ToI16(b64); + if (!pcm.length) return; + + // 电平:直接用这片 PCM 的峰值(替掉原来壳上报的 getMaxAmplitude) + const db = peakDb(pcm); + lastRealLevelAt = Date.now(); + levelTarget = db === -Infinity ? 0 : dbToLevel(db); + startLoop(); + + segChunks.push(pcm); + segLen += pcm.length; + // 静音按「整片」判:壳一片约 100ms,足够分辨 0.5s 的停顿(再细也没意义) + silLen = db < VAD_SILENCE_DB ? silLen + pcm.length : 0; + + if (silLen >= pcmRate * VAD_PAUSE_SEC) { + // 停顿够了 → 把静音之前的部分发走,静音本身丢掉(不浪费上游额度) + const tail = segLen - silLen; + emitSegment(tail); + clearSeg(); + } else if (segLen >= pcmRate * VAD_MAX_SEG_SEC) { + // 一口气说了 25 秒没停顿:硬切(宁可切开也不能超上游上限) + emitSegment(segLen); + clearSeg(); } }; + // 松手/超时:把不足一个停顿的尾巴也发出去,然后等全部段回来。 + // 必须剔掉尾巴上的静音:停顿那一下已经把缓冲清空了,之后累积的可能全是静音 + //(用户停一会儿才松手),发出去只会换来一次「没有可识别语音」。 + function flushTail() { + streamOn = false; + const speech = segLen - silLen; + if (speech > 0) emitSegment(speech); + clearSeg(); + } + + function waitFlush() { + const my = gen; + flushTimer = setTimeout(function () { + flushTimer = null; + if (my !== gen) return; + gen++; // 让迟到结果失效 + resetUI(); + toast('语音识别超时'); + }, FLUSH_MS); + chain = chain.then(function () { + if (my !== gen) return; + if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; } + const text = joinText(textParts); + // 先收遮罩再做后续:toast 固定在 bottom:96px,遮罩还在时弹出来会压住声波 + resetUI(); + if (!text) { toast('没有识别到内容'); return; } + ta.value = text; + send(); + }); + } + window.onNativeVoiceState = function (s) { if (!native || s !== 'recording' || phase !== 'recording') return; - // 真正开录:60s 与「太短」判定从这一刻算(首次授权弹窗的时间不算) + // 真正开录:180s 与「太短」判定从这一刻算(首次授权弹窗的时间不算) recordStartAt = Date.now(); if (stopTimer) clearTimeout(stopTimer); stopTimer = setTimeout(finishHold, MAX_MS); @@ -523,6 +668,7 @@ window.onNativeVoiceError = function (code, message) { if (phase === 'idle') return; + abortStream(); resetUI(); // 生命周期打断(切后台/换页)属预期,不弹提示 if (code === 'cancelled' || code === 'canceled') return; diff --git a/docs/voice-input.md b/docs/voice-input.md index 54bc8c1..f89f26c 100644 --- a/docs/voice-input.md +++ b/docs/voice-input.md @@ -1,36 +1,33 @@ # 语音输入:客户端录音契约 -链路是「按住说话 → 客户端录音 → `POST /api/asr/transcribe` → 转写结果**自动发送**」。 -服务端只收音频字节,不关心是谁录的。`public/js/voice.js` 按能力自己选录音方式: +链路是「按住说话 → 壳持续推 PCM → 页面按停顿切段并逐段转写 → 松手后一次性写入输入框并**自动发送**」。 -| 页面环境 | 录音方式 | 说明 | -|---|---|---| -| Android 套壳 App(WebView) | **原生录音 + JS 桥** | WebView 没有 Web Speech API;http 页面也允许 `getUserMedia` 的替代路径 | -| 浏览器 / PWA(HTTPS) | `MediaRecorder` | 标准 `getUserMedia`,不用改壳 | -| 纯浏览器(`http://`) | 不可用 | 非安全上下文,浏览器拒绝开麦 | +`public/js/voice.js` 按能力自己选录音方式: -**发送键的四种状态**(`sessions.js` 的 `updateSendBtn` 决定): +| 页面环境 | 录音方式 | 实时断句 | 说明 | +|---|---|---|---| +| Android 套壳 App(WebView) | **原生 `AudioRecord` + JS 桥流式推 PCM** | ✅ | WebView 没有 Web Speech API;`http://` 页面也能用 | +| 浏览器 / PWA(HTTPS) | `MediaRecorder` 整段录 | ❌(下一阶段) | 标准 `getUserMedia`,松手后整体上传 | +| 纯浏览器(`http://`) | 不可用 | — | 非安全上下文,浏览器拒绝开麦 | -| `data-state` | 什么时候 | 点击行为 | -|---|---|---| -| `stop` | 生成中且输入框为空 | 停止当前回合(优先级最高,不被语音入口顶掉) | -| `voice` | 空闲、无文字无附件、且语音可用 | 进入语音模式 | -| `keyboard` | 已在语音模式 | 回键盘模式,聚焦输入框(移动端弹键盘) | -| `send` | 其余情况 | 发送 | - -「语音可用」= ①有录音能力(原生桥,或安全上下文下的 `MediaRecorder`)②`GET /api/asr/status` -返回 `enabled !== false`。所以**套壳 App 里即使页面是 `http://`,只要桥注入成功,麦克风入口照样出现**; -纯浏览器 `http://` 不会出现(非安全上下文,浏览器禁止开麦)。 - -语音模式下输入框被 `#voice-hold` 取代(只有居中文字,无按钮外观):按住后整块输入区被 -**全宽遮罩**盖住(`#voice-overlay`,向左右各扩到屏幕边缘),遮罩里是「实时电平声波 + 提示文案」。 -手指上滑进入文案区域 → 取消态(声波与文案变红,文案改为「松开取消」),滑回下方恢复; -松手时取消态则**直接丢弃**(不弹 toast——它会盖住声波,取消本身已经有变色/文案反馈),否则转写并直接发送。 -松手后遮罩保持到识别结束,文案换成「正在识别…」。发送键变成键盘按钮。 +**为什么必须要流式**:录音只在松手后才上传的话,识别要等整段录完 + 整段识别,长语音尤其慢。 +流式之后,说话过程中的每个停顿都会立刻切段上传,**松手时通常只剩最后一段要等**。 --- -## 一、桥的契约 +## 一、交互与页面行为(壳只需要知道这些) + +1. 用户按住 `#voice-hold` → 页面调 `startVoice()`,同时把整块输入区换成全宽遮罩(实时声波 + 提示文案)。 +2. 壳开始推 PCM 分片;页面自己判停顿(连续静音 ≥0.5s)→ 立即 POST 该段 → 结果攒在内存里。 +3. 手指上滑进入文案区 = 取消态;松手时处于取消态则**整轮丢弃**(已上传段的结果也丢掉),输入框保持原样。 +4. 松手 → 页面把尾巴里**有声音的部分**发出去(纯静音的尾巴不发,否则只会换来一次「没有可识别人声」) + → 等所有段回来 → **一次性**写进输入框 → 自动发送。 +5. 识别结果**不会边识别边显示**:遮罩/发送键本来就盖住了输入框,渐进文本用户看不到, + 所以统一在最后落到输入框里,用户拿到的是完整一句话。 + +--- + +## 二、桥的契约 ### 1. 注入时机 @@ -49,69 +46,66 @@ webView.loadUrl(startUrl); ```js window.AgentNative = { - startVoice(), // 开始录音;失败/拒绝通过 onNativeVoiceError 回报 - stopVoice(), // 结束录音;结果通过 onNativeVoiceResult 回传 + startVoice(), // 开始录音(可能先弹权限);失败通过 onNativeVoiceError 回报 + stopVoice(), // 结束录音;**没有返回值**,页面自己等已发出的分段的识别结果 cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了) }; ``` -**线程模型**:这三个方法都跑在 WebView 的 JavaBridge 子线程上,**不是主线程**。 -`MediaRecorder` 的所有调用必须收敛到主线程:方法入口先 `mainHandler.post(...)`, -读临时文件 + Base64 才放回子线程。 - ### 3. 回调(页面定义,壳调用) ```js -window.onNativeVoiceResult(base64, mime) // mime 例:'audio/mp4' -window.onNativeVoiceError(code, message) // 见下方错误码表 -window.onNativeVoiceState('recording') // 建议实现:真正开始录时调一次 -window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~32767,驱动遮罩里的声波 +window.onNativeVoiceChunk(base64Pcm, sampleRate) // 必需:流式 PCM 分片 +window.onNativeVoiceState('recording') // 建议:真正开始录时调一次 +window.onNativeVoiceError(code, message) // 出错/被打断时调 ``` -- `onNativeVoiceAmp(amp)`:壳只上报 `MediaRecorder.getMaxAmplitude()` 的**原始值** - (0~32767,主线程每 100ms 一次),**不要做任何换算**。dB 归一化、静音门限、快攻慢放平滑 - 全部在页面侧——浏览器(RMS)和壳(峰值)两条路的规则只存在一份。 - 旧名 `onNativeVoiceLevel` 仍作为别名接受(同样按原始幅度解释)。 - 不实现也能用:声波静默停在基线上(不空转、不假动)。 - JS 侧还要自己做快攻慢放平滑,壳不需要平滑。 -- `onNativeVoiceState('recording')`:**按住说话的时长判定依赖它**。页面用这个回调重置 - 「60 秒上限」和「太短丢弃」的起点,避免首次授权弹窗的时间被算进录音。不实现也不会崩: - 页面按点击时刻计时,代价是首次授权那一次会被当成「太短」丢弃(用户再按一次即可)。 -- 页面收到 `onNativeVoiceResult` 后会直接发送消息(不经过输入框、不可编辑)。 -- 所有回调都必须在**主线程**调 `webView.evaluateJavascript`。 -- 字符串一律用 `JSONObject.quote(...)` 拼,不要手写 `'` 转义——异常 message 里可能有 - `\`、换行、U+2028,会把整段脚本打断。 +#### `onNativeVoiceChunk(base64Pcm, sampleRate)` -### 4. 状态机与错误码 +- 内容:**裸 PCM**,`16bit 小端 / 单声道 / 16kHz`(小端是 `AudioRecord` 的原始字节序,直接转 Base64 即可)。 +- 节奏:约 **100ms 一片**(1600 采样 = 3200 字节,Base64 后约 4.3KB)。50~200ms 都可接受。 +- 壳**不做任何数学**:不判静音、不切段、不算音量。dB 归一化、静音门限、停顿判定、切段 + 全部在页面侧(`voice.js`),规则只存在一份。 +- 声波也是页面用这片 PCM 的峰值算的——**不再需要** `onNativeVoiceAmp` / `getMaxAmplitude`。 +- 页面已经复位(用户松手/取消)后再来的分片会被忽略,壳不用刻意等待。 -壳侧状态:`IDLE → (WAITING_PERMISSION) → RECORDING → ENCODING → IDLE`。 -`startVoice` 只在 `IDLE` 生效,`stopVoice` 只在 `RECORDING` 生效(其余静默忽略)。 +#### `onNativeVoiceState('recording')` + +**按住时长判定依赖它**:页面用这个回调重置「180 秒上限」与「太短丢弃」的起点, +避免首次授权弹窗的时间被算进录音。不实现也不会崩,但首次授权那一次可能被当成「太短」丢掉。 + +#### `onNativeVoiceError(code, message)` | code | 触发时机 | 页面表现 | |---|---|---| -| `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「需要麦克风权限」 | -| `start_failed` | `prepare()` / `start()` 抛异常(含回退 MIC 后仍失败) | toast | -| `too_short` | `stop()` 抛异常(录音 < ~1s) | toast「说话时间太短,请按住再说」,**不上传** | -| `read_failed` | 读临时文件失败 | toast | +| `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「录音失败:…」 | +| `start_failed` | `AudioRecord` 初始化/启动失败(含 16k 不支持) | toast | +| `read_failed` | 采集线程读失败 | toast | +| `forbidden` | 非白名单 URL / 应用不在前台 | toast | | `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** | | 其他未知 code | — | toast 里显示 `message`,没有就显示 code | -**取消语义**:页面在 `stopVoice()` 之后会一直等结果(直到点击后 90 秒的硬超时), -所以壳在生命周期里取消录音时**必须**回调 `onNativeVoiceError('cancelled','')`, -否则按钮会卡在「录音中」。`cancelVoice()` 是页面主动发起的,壳不需要回报。 +**取消语义**:页面在 `stopVoice()` 之后只等自己发出的分段请求(不再等壳回音频), +所以壳在生命周期里中断录音时**仍建议**回调 `onNativeVoiceError('cancelled','')`, +让页面立刻收遮罩,不必干等。`cancelVoice()` 是页面主动发起的,壳不需要回报。 -### 5. 体积与时序 +### 4. 体积与时序 -- 16kHz / 32kbps / 单声道 AAC:60 秒 ≈ **240KB**,Base64 后 ≈ **320KB**。 -- `evaluateJavascript` 走 Binder,单次约 1MB 上限;320KB 安全,但**不要再延长单次时长**。 - 真要 2 分钟以上,改成按段回传或本地 HTTP 回传。 -- 松开后页面最多等 3 秒拿音频(等不到就复位,覆盖「壳还在等权限」的情况); - 拿到后上传+识别,正常 1~2 秒。 -- 按住时间 < 500ms 视为误触:页面直接丢弃,不上传;壳自己的 `too_short` 是第二道保险。 +- 每秒 32KB 原始 PCM(16k × 2 字节),Base64 后约 43KB/s;一片 100ms 约 4.3KB。 + `evaluateJavascript` 走 Binder,单次约 1MB 上限,4.3KB 远低于上限。 +- 一次 60 秒的听写 = 约 600 次桥调用、2.6MB 字符串。Android WebView 完全吃得住, + 但**不要**把分片缩到 20ms 以下(调用次数会翻 5 倍,收益为零)。 +- 页面侧开销:每片扫一遍峰值(1600 个 short),可忽略。 + +### 5. 壳侧状态机 + +`IDLE → (WAITING_PERMISSION) → RECORDING → IDLE` + +`startVoice` 只在 `IDLE` 生效,`stopVoice` / `cancelVoice` 在非 `RECORDING` 时静默忽略。 --- -## 二、Java 参考骨架(纯 Java / minSdk 21) +## 三、Java 参考骨架(纯 Java / minSdk 21) 只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。 @@ -121,32 +115,21 @@ window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~3276 public final class VoiceBridge { private static final int REQ_MIC = 1001; - private static final long MAX_MS = 60_000; + private static final int RATE = 16000; // 契约固定:16k / 单声道 / 16bit + private static final int CHUNK_MS = 100; // 每 100ms 推一片 + private static final long MAX_MS = 180_000; // 页面也会自己停,这里是兜底 - private enum State { IDLE, WAITING_PERMISSION, RECORDING, ENCODING } + private enum State { IDLE, WAITING_PERMISSION, RECORDING } private final Activity activity; private final WebView webView; private final Handler main = new Handler(Looper.getMainLooper()); private final Runnable autoStop = this::stopOnMain; - // 实时电平:每 100ms 读一次 getMaxAmplitude() 交给页面画声波 - private static final long LEVEL_INTERVAL_MS = 100; - private final Runnable levelTick = this::tickLevel; - - private void tickLevel() { - MediaRecorder r = recorder; - if (state != State.RECORDING || r == null) return; - int amp = 0; - try { amp = r.getMaxAmplitude(); } catch (Exception ignored) { } - // 原始幅度直接给页面:dB 归一化/门限/平滑全在 JS,壳不做任何数学 - js("window.onNativeVoiceAmp && window.onNativeVoiceAmp(" + amp + ")"); - main.postDelayed(levelTick, LEVEL_INTERVAL_MS); - } - private State state = State.IDLE; - private MediaRecorder recorder; - private File file; + private AudioRecord record; + private Thread worker; + private volatile boolean running; public VoiceBridge(Activity activity, WebView webView) { this.activity = activity; @@ -159,15 +142,13 @@ public final class VoiceBridge { @JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); } // ---- 生命周期:由 Activity / WebViewClient 调用 ---- - // 注意:只取消真正在录/在编码的状态。授权弹窗期间某些 ROM 会走 onPause, - // 那里如果一并取消,首次授权的两段式流程就断了。 + // 只在真正录音时取消。授权弹窗期间某些 ROM 会走 onPause, + // 那里一并取消的话,首次授权的两段式流程就断了。 public void onPause() { - main.post(() -> { - if (state == State.RECORDING || state == State.ENCODING) cancelOnMain(true); - }); + main.post(() -> { if (state == State.RECORDING) cancelOnMain(true); }); } - public void onDestroy() { main.post(() -> cancelOnMain(false)); } - public void onPageChanged() { main.post(() -> cancelOnMain(true)); } + public void onDestroy() { main.post(() -> cancelOnMain(false)); } + public void onPageChanged() { main.post(() -> cancelOnMain(true)); } public void onRequestPermissionsResult(int requestCode, int[] grantResults) { if (requestCode != REQ_MIC) return; @@ -177,7 +158,7 @@ public final class VoiceBridge { boolean ok = grantResults != null && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED; if (!ok) { fail("no_permission", "需要麦克风权限"); return; } - beginRecording(); // 授权后直接开录(体验优先,不要求用户再点一次) + beginRecording(); // 授权后直接开录,不让用户再点一次 }); } @@ -198,105 +179,96 @@ public final class VoiceBridge { beginRecording(); } - @SuppressLint("NewApi") private void beginRecording() { + int minBuf = AudioRecord.getMinBufferSize( + RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT); + if (minBuf <= 0) { fail("start_failed", "设备不支持 16kHz 录音"); return; } + // VOICE_RECOGNITION 关掉 AGC/降噪,对 ASR 更友好;个别机型不支持则回退 MIC + final AudioRecord r = createRecord(minBuf); + if (r == null) { fail("start_failed", "无法开始录音"); return; } + + record = r; + running = true; + state = State.RECORDING; + main.postDelayed(autoStop, MAX_MS); + + final int samplesPerChunk = RATE * CHUNK_MS / 1000; // 1600 + worker = new Thread(() -> captureLoop(r, samplesPerChunk), "voice-capture"); + worker.start(); + + // 让页面的 180s 从“真的开始录”算(授权弹窗的时间不算) + js("window.onNativeVoiceState && window.onNativeVoiceState('recording')"); + } + + private AudioRecord createRecord(int minBuf) { int[] sources = {MediaRecorder.AudioSource.VOICE_RECOGNITION, MediaRecorder.AudioSource.MIC}; for (int source : sources) { - File f = null; - MediaRecorder r = null; try { - f = File.createTempFile("voice", ".m4a", activity.getCacheDir()); - r = Build.VERSION.SDK_INT >= 31 - ? new MediaRecorder(activity) // 无参构造在 API 31 起废弃 - : new MediaRecorder(); - r.setAudioSource(source); - r.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); - r.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); - r.setAudioSamplingRate(16000); - r.setAudioEncodingBitRate(32000); - r.setAudioChannels(1); - r.setOutputFile(f.getAbsolutePath()); - r.prepare(); - r.start(); + AudioRecord t = new AudioRecord(source, RATE, AudioFormat.CHANNEL_IN_MONO, + AudioFormat.ENCODING_PCM_16BIT, Math.max(minBuf * 2, 8192)); + if (t.getState() == AudioRecord.STATE_INITIALIZED) return t; + t.release(); + } catch (Exception ignored) { /* 换下一个 source */ } + } + return null; + } - recorder = r; - file = f; - state = State.RECORDING; - main.postDelayed(autoStop, MAX_MS); - main.postDelayed(levelTick, LEVEL_INTERVAL_MS); - // 让页面的 60s 从“真的开始录”算(授权弹窗的时间不算) - js("window.onNativeVoiceState && window.onNativeVoiceState('recording')"); - // 不要再额外弹原生 Toast:页面遮罩已经给了全部反馈,弹窗会压住声波 - return; - } catch (Exception e) { - // 局部变量释放:失败时 recorder 字段还没赋值,releaseQuietly() 管不到它 - if (r != null) { - try { r.stop(); } catch (Exception ignored) { } - try { r.release(); } catch (Exception ignored) { } + /** 采集线程:阻塞 read → 小端字节 → Base64 → 推给页面。不判静音、不切段。 */ + private void captureLoop(AudioRecord r, int samplesPerChunk) { + short[] pcm = new short[samplesPerChunk]; + byte[] bytes = new byte[samplesPerChunk * 2]; + try { + r.startRecording(); + while (running) { + int n = r.read(pcm, 0, pcm.length); + if (n <= 0) continue; + for (int i = 0; i < n; i++) { + bytes[i * 2] = (byte) (pcm[i] & 0xff); + bytes[i * 2 + 1] = (byte) ((pcm[i] >> 8) & 0xff); } - delete(f); + String b64 = Base64.encodeToString(bytes, 0, n * 2, Base64.NO_WRAP); + // 字符串一律 JSONObject.quote,避免任何转义问题(Base64 本身安全,这里是统一规矩) + js("window.onNativeVoiceChunk(" + JSONObject.quote(b64) + "," + RATE + ")"); } + } catch (Exception e) { + if (running) fail("read_failed", "录音中断:" + e.getMessage()); + } finally { + try { r.stop(); } catch (Exception ignored) { } + try { r.release(); } catch (Exception ignored) { } } - state = State.IDLE; - fail("start_failed", "无法开始录音"); } private void stopOnMain() { if (state != State.RECORDING) return; main.removeCallbacks(autoStop); - main.removeCallbacks(levelTick); // 停止上报电平 - state = State.ENCODING; - - MediaRecorder r = recorder; - File f = file; - recorder = null; - file = null; - - boolean stopped = true; - try { r.stop(); } catch (RuntimeException e) { stopped = false; } // 太短会抛 - try { r.release(); } catch (Exception ignored) { } - - if (!stopped) { - delete(f); - state = State.IDLE; - fail("too_short", "没有录到声音"); - return; - } - new Thread(() -> { - try { - byte[] bytes = readAll(f); - String b64 = Base64.encodeToString(bytes, Base64.NO_WRAP); - delete(f); - main.post(() -> { - state = State.IDLE; - js("window.onNativeVoiceResult(" + JSONObject.quote(b64) + ",'audio/mp4')"); - }); - } catch (Exception e) { - delete(f); - main.post(() -> { state = State.IDLE; fail("read_failed", "读取录音失败"); }); - } - }, "voice-encode").start(); + stopCapture(); + state = State.IDLE; + // 注意:这里不再回传音频,识别分段已经在录音过程中发完了 } - /** notify=true:页面在等结果,必须回 cancelled 让它复位;onDestroy 时页面已走,不必回。 */ + /** notify=true:页面在等收尾,回 cancelled 让它立刻收遮罩;onDestroy 时页面已走,不必回。 */ private void cancelOnMain(boolean notify) { main.removeCallbacks(autoStop); - main.removeCallbacks(levelTick); boolean wasActive = state != State.IDLE; - releaseQuietly(); - delete(file); - file = null; + stopCapture(); state = State.IDLE; if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')"); } - private void releaseQuietly() { - if (recorder == null) return; - try { recorder.stop(); } catch (Exception ignored) { } - try { recorder.release(); } catch (Exception ignored) { } - recorder = null; + private void stopCapture() { + running = false; + AudioRecord r = record; + record = null; + if (r != null) { + // 打断阻塞中的 read();stop/release 由采集线程的 finally 做, + // 避免跨线程操作同一个 AudioRecord + try { r.stop(); } catch (Exception ignored) { } + } + Thread w = worker; + worker = null; + if (w != null) w.interrupt(); } private void fail(String code, String message) { @@ -307,20 +279,6 @@ public final class VoiceBridge { private void js(String script) { webView.post(() -> webView.evaluateJavascript(script, null)); } - - private static byte[] readAll(File f) throws Exception { - try (FileInputStream in = new FileInputStream(f); - ByteArrayOutputStream out = new ByteArrayOutputStream()) { - byte[] buf = new byte[8192]; - int n; - while ((n = in.read(buf)) > 0) out.write(buf, 0, n); - return out.toByteArray(); - } - } - - private static void delete(File f) { - if (f != null) f.delete(); - } } ``` @@ -334,46 +292,61 @@ webView.addJavascriptInterface(new VoiceBridge(this, webView), "AgentNative"); super.onRequestPermissionsResult(code, p, r); bridge.onRequestPermissionsResult(code, r); } -@Override protected void onPause() { bridge.onPause(); super.onPause(); } -@Override protected void onDestroy() { bridge.onDestroy(); super.onDestroy(); } +@Override protected void onPause() { bridge.onPause(); super.onPause(); } +@Override protected void onDestroy() { bridge.onDestroy(); super.onDestroy(); } // WebViewClient.onPageStarted:URL 变了就 bridge.onPageChanged() ``` +**和上一版(MediaRecorder)的差别,别照抄旧代码**: + +- 不再有 `MediaRecorder`、临时文件、`onNativeVoiceResult`、`getMaxAmplitude`、60 秒自动停止。 +- `stopVoice()` 之后没有任何回传动作,页面会自己等已发出的分段请求。 +- 必须在**采集线程**里 `read()`,不能读在主线程;`AudioRecord` 的 stop/release 只由该线程的 + `finally` 执行(主线程只调 `stop()` 打断阻塞)。 +- 个别设备 16k 不支持时:`getMinBufferSize` 会返回负数。此时要么回滚到 44.1k 并在壳里做 + 2 点平均降采样到 16k(多几十行),要么直接 `start_failed`。**不要**改推 44.1k 给页面—— + 页面只按 16k 估算时长与切段。 + --- -## 三、壳侧必须同步的清单 +## 四、壳侧必须同步的清单 | 项 | 内容 | |---|---| | `AndroidManifest.xml` | `` | | `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface ; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 | -| README 安全表 | 从「不使用 JS 桥」改为「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 | +| README 安全表 | 「不使用 JS 桥」→「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 | | README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 | -| 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机;建议再加一个原生 Toast 提示录音已开始(外部 CDN 脚本与页面同源,能调桥,但用户至少看得见) | -| 页面导航 | `onPageStarted` 且 URL 变化时取消,避免 base64 打到新页面的回调上 | +| 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机 | +| 页面导航 | `onPageStarted` 且 URL 变化时取消;分片打到新页面会污染新一轮的缓冲 | +| 录音上限 | 壳侧兜底 180s(页面也会在 180s 时主动 `stopVoice()`),不要做成 60s | > 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用, > 不建议默认开。 --- -## 四、iOS(以后若有 WKWebView 壳) +## 五、iOS(以后若有 WKWebView 壳) -契约相同,换注入方式: +契约相同,只是数据源换成 `AVAudioEngine` 的 tap(`installTapOnBus` 直接把 +`AVAudioPCMBuffer` 转成 16bit 小端 PCM,每 ~100ms 一次): ```swift // 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...) -// 录音:AVAudioRecorder(16kHz / 单声道 / m4a) -// 回传:webView.evaluateJavaScript("window.onNativeVoiceResult('\(b64)','audio/mp4')") +// 推流:webView.evaluateJavaScript("window.onNativeVoiceChunk('\(b64)',16000)") +// 结束:stopVoice() 停 tap 即可,不需要回传文件 ``` `Info.plist` 需要 `NSMicrophoneUsageDescription`。 -## 五、服务端接口 +--- + +## 六、服务端接口 ```http POST /api/asr/transcribe -Content-Type: audio/mp4 # 或 audio/webm / audio/wav / application/octet-stream +Content-Type: audio/wav # 套壳推的是 wav(页面自己加的 44 字节头); + # 浏览器仍可能是 audio/mp4 / audio/webm Cookie: <登录态> # 与页面同一份 HttpOnly cookie <音频二进制> @@ -384,13 +357,13 @@ Cookie: <登录态> # 与页面同一份 HttpOnly cookie ``` - 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。 -- `GET /api/asr/status` → `{"enabled": true}`;未接线时 `{"enabled": false, "reason": "..."}`, - 三种情况:core 的 `ASR_URL` 为空、`config.yml` 里没有启用的 `asr` 段、该段缺 `X-ASR-Base-Url`。 -- 上游(key / base_url / model)不在 `mcp_asr` 容器里:core 从 `config.yml` 的 - `mcp_servers[name=asr].headers` 取出并随请求带给它(`Authorization` / `X-ASR-Base-Url` / `X-ASR-Model`), - 所以换 ASR 平台只改 YAML + 重启 core。 +- 一次「按住说话」在套壳里会变成 **多次** 请求(每个停顿一次)。页面串行发送,保证拼接顺序。 +- 单段失败不影响其他段(页面侧吞掉单段错误,继续等下一段);全部失败才提示。 +- 服务端只做**超长兜底**:一次请求超过 25s 才切,且切点尽量落在停顿处(套壳已经按停顿切好了, + 这里多数请求根本不会触发切分)。参数见 `mcp/asr/README.md`。 +- `GET /api/asr/status` → `{"enabled": true}`;未接线时 `{"enabled": false, "reason": "..."}`。 -## 六、为什么不用浏览器的 Web Speech API +## 七、为什么不用浏览器的 Web Speech API - Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。 - 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。 diff --git a/mcp/asr/README.md b/mcp/asr/README.md index 637d90d..4121979 100644 --- a/mcp/asr/README.md +++ b/mcp/asr/README.md @@ -74,9 +74,13 @@ curl -s -X POST http://mcp_asr:3000/transcribe \ # → {"text":"打开今天的日报","ms":842,"model":"whisper-1"} ``` -- 上限 20MB;超过 `ASR_MAX_CHUNK_SEC`(默认 25s)的音频自动切片后逐段识别再拼接 - (多数云端 ASR 单次只吃 ~30s)。 -- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写,超了回 429。 +- 上限 20MB。**只有超过 `ASR_MAX_CHUNK_SEC`(默认 25s)才切**:套壳是流式的,一次请求本就是一�句话, + 直接一次送出去(不跑静音检测);长音频(浏览器整段上传 / `/mcp`)才需要断开。 +- 切点尽量落在停顿上:只在距上限最后 `ASR_CUT_LOOKBACK_SEC`(默认 6s)的窗口里找静音区间中点, + 挑不到才硬切——硬切会把字劈成两半,而两段之间没有上下文,接缝处的字就丢了。 + 段数因此最少(≈ 时长/25),不存在“切太碎”的退化。单段不短于 `ASR_MIN_SEG_SEC`(默认 1s)。 +- 单段失败不连坐:其余段照常返回(长录音里偶发静音段很常见);**全部**段失败才报错。 +- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写请求,超了回 429。 ## MCP 工具 @@ -100,10 +104,14 @@ mcp_servers: | 变量 | 默认 | 说明 | |---|---|---| | `ASR_MAX_BYTES` | 20971520 | 单次上传上限 | -| `ASR_MAX_CHUNK_SEC` | `25` | 超长音频切片长度,`0` = 不切 | +| `ASR_PAUSE_SEC` | `0.5` | 多长的静音算一个停顿(`silencedetect` 的 `d`,仅在需要切时用) | +| `ASR_SILENCE_DB` | `-35` | 判定“没人说话”的音量门限(正常语音约 -20dB) | +| `ASR_MIN_SEG_SEC` | `1` | 单段最短;避免切出识别不了的碎片 | +| `ASR_MAX_CHUNK_SEC` | `25` | 单段最长;≤ 它就不切(一次请求) | +| `ASR_CUT_LOOKBACK_SEC` | `6` | 切点搜索窗:只在距上限最后这几秒里找停顿 | | `ASR_MAX_CONCURRENT` | `2` | 并发转写数 | | `ASR_LOG_LEVEL` | `info` | debug / info / warn / error / none | -| `FFMPEG_BIN` | `ffmpeg` | 归一化工具路径 | +| `FFMPEG_BIN` | `ffmpeg` | 归一化 / 静音检测工具路径 | 上游参数(key / base_url / model)**不是环境变量**,见上面「上游」一节。 diff --git a/mcp/asr/src/server.js b/mcp/asr/src/server.js index 2c2d062..74587ac 100644 --- a/mcp/asr/src/server.js +++ b/mcp/asr/src/server.js @@ -18,6 +18,10 @@ // model——一律由调用方随请求 header 带入,本容器不存任何平台密钥、也不认任何平台默认值。 // 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac, // 上游只认 wav/mp3,归一化后两端都自由。 +// +// 超长兜底:只有超过单次上限(默认 25s)才断开重发,切点尽量落在停顿上。 +// 套壳是流式的(客户端已按停顿切好,一次请求就是一句话),所以这里多数请求不会被切; +// 真正用得上的是浏览器整段上传与 /mcp 转写已有长音频。 import http from 'node:http'; import { spawn } from 'node:child_process'; @@ -40,9 +44,24 @@ const HDR_BASE = 'x-asr-base-url'; const HDR_MODEL = 'x-asr-model'; // 单次上传上限。60s 的 AAC 约 240KB、16k wav 约 1.9MB,20MB 是给长音频留的余量。 const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024)); -// 云端多数 ASR 单次只吃 ~30s:超长音频按这个秒数切片后逐段识别再拼接(0 = 不切)。 +// ── 超长兜底切分 ────────────────────────────────────────────────────── +// 谁需要它:套壳是流式的(客户端已经按停顿切好,每次请求就是一句话), +// 所以这里绝大多数请求都 ≤ 25s 直接一次送出去;真正用得上的只有 +// 「浏览器整段上传」和「/mcp 转写已有长音频」——它们可能一次给几分钟。 +// 切点尽量落在停顿上:硬切会把字劈成两半,而两段之间又没有上下文,接缝处的字就丢了。 +// 0.5s 是句子边界:换气/想词的停顿通常 0.3~0.8s,而 0.5s 以下是词内间隔。 +const PAUSE_SEC = Math.max(0.1, Number(process.env.ASR_PAUSE_SEC || 0.5)); +// 判定为「没人说话」的音量门限:正常语音约 -20dB,安静房间底噪 -60dB 以下。 +const SILENCE_DB = Number(process.env.ASR_SILENCE_DB || -35); +// 单段最短:避免最后切出一个没法识别的碎片(并进前一段)。 +const MIN_SEG_SEC = Math.max(0, Number(process.env.ASR_MIN_SEG_SEC || 1)); +// 单段最长(≈ 上游单次能吃的大致上限):超过它就必须断开。 // 16k/16bit 单声道 wav 恒为 32000 B/s,所以用文件大小就能估时长,不用再起 ffprobe。 -const CHUNK_SEC = Math.max(0, Number(process.env.ASR_MAX_CHUNK_SEC || 25)); +const CHUNK_SEC = Math.max(1, Number(process.env.ASR_MAX_CHUNK_SEC || 25)); +// 切点搜索窗:只在「距上限还差这么多秒」的范围里找停顿。 +// 不从头找是为了每段都尽量接近 25s——否则开头一个 2s 的停顿也会被拿来切, +// 段数无谓变多(请求开销远大于多切一刀的收益)。 +const CUT_LOOKBACK_SEC = Math.max(0, Number(process.env.ASR_CUT_LOOKBACK_SEC || 6)); // 同时转写数:2 vCPU 上并发再高只会互相拖慢。 const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2)); @@ -141,21 +160,83 @@ async function toWav(buf, ext) { } } -// 按秒切片:只在超过 CHUNK_SEC 时做。切片用 -c copy,纯 PCM 无损。 -async function splitWav(wavPath, chunkSec) { +// ── 停顿检测与切点规划 ───────────────────────────────────────────────── +// 用 ffmpeg 的 silencedetect 找静音区间:容器里本来就有 ffmpeg,它的判定也处理过 +// 重采样/编码的各种边角,比自己扫 PCM 算 RMS 更省心(一次遍历,30s 音频约 50~150ms)。 +// 返回 [{start,end}](秒)。末尾那段一直静到文件结束的不会有 silence_end,直接丢掉—— +// 尾巴不需要切。 +function parseSilences(stderr) { + const out = []; + let cur = null; + for (const line of String(stderr || '').split('\n')) { + const s = /silence_start:\s*(-?[\d.]+)/.exec(line); + if (s) { cur = { start: Number(s[1]), end: null }; out.push(cur); continue; } + const e = /silence_end:\s*(-?[\d.]+)/.exec(line); + if (e && cur) { cur.end = Number(e[1]); cur = null; } + } + return out.filter((p) => p.end != null && p.end > p.start && p.start >= 0); +} + +async function detectPauses(wavPath) { + const r = await run(FFMPEG, [ + '-hide_banner', '-nostats', '-i', wavPath, + '-af', 'silencedetect=noise=' + SILENCE_DB + 'dB:d=' + PAUSE_SEC, + '-f', 'null', '-', + ], 60000); + return parseSilences(r.stderr); +} + +// 由「时长 + 静音区间」规划切点,返回 [0, c1, …, duration]。 +// 贪心:每次只在「还没超上限」的范围内挑一个切点,因此段数最少(≈ 时长/CHUNK_SEC)。 +// 只在最后 CUT_LOOKBACK_SEC 秒里找停顿;找不到就硬切到上限处。 +function planCuts(duration, pauses) { + const mids = pauses.map((p) => (p.start + p.end) / 2); + const cuts = [0]; + let cur = 0; + while (duration - cur > CHUNK_SEC) { + const limit = cur + CHUNK_SEC; + const floor = Math.max(cur + MIN_SEG_SEC, limit - CUT_LOOKBACK_SEC); + let pick = 0; + for (const t of mids) { + if (t >= floor && t <= limit && t > pick) pick = t; // 取窗口内最靠后的停顿中点 + } + if (!pick) pick = limit; // 没有停顿:硬切 + // 别切出一个短于 MIN_SEG_SEC 的尾巴(如 25.6s 不该切成 25 + 0.6):对半分 + if (duration - pick < MIN_SEG_SEC) pick = cur + (duration - cur) / 2; + cuts.push(pick); + cur = pick; + } + cuts.push(duration); + return cuts; +} + +// 按规划好的切点切片。16k/单声道/s16le 的 PCM 用 -c copy 无损切(不重编码)。 +async function splitWav(wavPath, cuts) { const dir = path.dirname(wavPath); const base = path.basename(wavPath, '.wav'); - const pattern = path.join(dir, base + '-part-%03d.wav'); - await run(FFMPEG, [ - '-hide_banner', '-loglevel', 'error', '-y', - '-i', wavPath, - '-f', 'segment', '-segment_time', String(chunkSec), '-c', 'copy', - pattern, - ], 60000); - const files = (await fs.readdir(dir)) - .filter((f) => f.startsWith(base + '-part-') && f.endsWith('.wav')) - .sort(); - return files.map((f) => path.join(dir, f)); + const parts = []; + for (let i = 0; i + 1 < cuts.length; i++) { + const p = path.join(dir, base + '-part-' + String(i).padStart(3, '0') + '.wav'); + await run(FFMPEG, [ + '-hide_banner', '-loglevel', 'error', '-y', + '-ss', String(cuts[i]), '-i', wavPath, '-t', String(cuts[i + 1] - cuts[i]), + '-c', 'copy', p, + ], 60000); + parts.push(p); + } + return parts; +} + +// 拼接各段文本:中文直接相连;两侧都是西文字母/数字时补一个空格, +// 否则英文句子被切开后会粘成 "helloworld"。 +function joinText(parts) { + let out = ''; + for (const s of parts) { + if (!s) continue; + if (out && /[A-Za-z0-9]$/.test(out) && /^[A-Za-z0-9]/.test(s)) out += ' '; + out += s; + } + return out; } // ── 引擎 ────────────────────────────────────────────────────────────────── @@ -211,8 +292,12 @@ async function runCloud(wavPath, up) { try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); } const text = extractText(obj); if (!text) { - const err = new Error('上游返回为空:' + raw.slice(0, 300)); - err.status = 502; + // 上游对「这段里没人声」会回 200 + 空 text(如 glm-asr 的 {duration,text:"",usage})。 + // 这是**正常结果**,不是故障:给 400 让上层只记一行 warn(5xx 才打堆栈), + // 前端按「没识别到」处理、页面侧单段失败也会被跳过。 + const err = new Error('没有识别到语音内容(这段音频里没有可识别的人声)'); + err.status = 400; + err.upstream = raw.slice(0, 300); throw err; } return text; @@ -241,9 +326,21 @@ async function transcribeBuffer(buf, opts) { // 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。 log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → ' + seconds.toFixed(1) + 's wav'); - if (CHUNK_SEC > 0 && seconds > CHUNK_SEC * 1.2) { - parts.push(...await splitWav(wavPath, CHUNK_SEC)); - log('info', '超长音频切成 ' + parts.length + ' 段'); + + // 只有超长才切:套壳是流式的,每次请求本来就是一�句话(1~5s), + // 这里直接一次送出去,不用白白跑一趟 silencedetect。 + let cuts = [0, seconds]; + if (seconds > CHUNK_SEC) { + const pauses = await detectPauses(wavPath).catch((e) => { + log('warn', '静音检测失败,按 ' + CHUNK_SEC + 's 硬切:' + String(e && e.message || e).slice(0, 160)); + return []; + }); + cuts = planCuts(seconds, pauses); + if (cuts.length > 2) { + parts.push(...await splitWav(wavPath, cuts)); + log('info', '超长切成 ' + parts.length + ' 段,切点 ' + + cuts.slice(1, -1).map((t) => t.toFixed(1) + 's').join(' / ')); + } } if (!parts.length) { try { @@ -259,15 +356,26 @@ async function transcribeBuffer(buf, opts) { } const out = []; - for (const p of parts) { + let firstErr = null; + for (let i = 0; i < parts.length; i++) { + const t0 = Date.now(); + const range = cuts[i].toFixed(1) + '–' + cuts[i + 1].toFixed(1) + 's'; // 每段独立识别;单段失败不连累其他段(长录音里偶发静音段常见) try { - out.push((await runCloud(p, up)).trim()); + const text = (await runCloud(parts[i], up)).trim(); + log('info', ' part ' + (i + 1) + '/' + parts.length + ' ' + range + ' → ' + + text.length + ' 字 / ' + (Date.now() - t0) + 'ms'); + out.push(text); } catch (e) { - log('warn', '切片识别失败(跳过):' + String(e && e.message || e).slice(0, 200)); + if (!firstErr) firstErr = e; + log('warn', ' part ' + (i + 1) + '/' + parts.length + ' ' + range + + ' 识别失败(跳过):' + String(e && e.message || e).slice(0, 200)); } } - return out.filter(Boolean).join(''); + // 全部失败才报错:否则前端只会看到 200 + 空文本,分不清是「没说话」还是「上游挂了」。 + // 部分失败保持静默降级(长录音里某一段坏了不该连坐)。 + if (!out.length && firstErr) throw firstErr; + return joinText(out); } finally { await fs.rm(wavPath, { force: true }).catch(() => {}); for (const p of parts) await fs.rm(p, { force: true }).catch(() => {});