Function async_asr

runtime/python/websocket/funasr_wss_server.py:583–680

(websocket, audio_in: bytes)

async def async_asr(websocket, audio_in: bytes):
    mode = "2pass-offline" if "2pass" in (websocket.mode or "") else websocket.mode

    if len(audio_in) <= 0:
        message = {
            "mode": mode,
            "text": "",
            "wav_name": websocket.wav_name,
            "is_final": True,
        }
        await websocket.send(json.dumps(message, ensure_ascii=False))
        return

    # 1) ASR（阻塞，线程池执行）
    rec_result_list = await run_blocking(
        _generate_sync,
        model_asr,
        audio_in,
        websocket.status_dict_asr,
        sem=SEM_ASR_OFFLINE,
    )
    rec_result = rec_result_list[0]

    print("offline_asr, raw:", rec_result)
    print("offline_asr, keys:", rec_result.keys())

    text = rec_result.get("text", "")
    timestamp = rec_result.get("timestamp", None)
    sentence_info = rec_result.get("sentence_info", None)

    # 2) 声纹识别（阻塞，线程池执行）
    spk_name = "unknown"
    best_score = 0.0
    try:
        spk_name, best_score = await run_blocking(
            _sv_and_match_sync,
            audio_in,
            int(args.speaker_db_reload_sec),
            sem=SEM_SV,
        )
    except Exception as e:
        print(f"声纹识别失败: {e}")

    # 3) 标点（阻塞，线程池执行）
    punc_array = None
    if model_punc is not None and len(text) > 0:
        try:
            # punc 只对文本处理
            punc_out = await run_blocking(
                _generate_sync,
                model_punc,
                text,
                websocket.status_dict_punc,
                sem=SEM_PUNC,
            )
            punc_result = punc_out[0]
            print("offline, after punc", punc_result)