diff --git a/README.md b/README.md index 79de1d2..f68ba54 100644 --- a/README.md +++ b/README.md @@ -1,110 +1,97 @@ -# FunASR WebSocket服务 +# FunASR FastAPI WebSocket Service -## 简介 -本项目基于FunASR实现了一个WebSocket语音识别服务,支持实时语音流的在线和离线识别。利用ModelScope开源语音模型,该服务可以进行高精度的中文语音识别,并支持语音活动检测(VAD)和自动添加标点符号。 +一个基于 FunASR 和 FastAPI 构建的高性能、实时的语音识别 WebSocket 服务。该项目核心特色是支持"一发多收"的广播模式,适用于会议实时字幕、在线教育、直播转写等需要将单一音源的识别结果分发给多个客户端的场景。 + +## ✨ 功能特性 + +- **实时语音处理**: 集成 FunASR 的语音活动检测(VAD)、语音识别(ASR)和声纹识别(SPK)模型。 +- **WebSocket 流式 API**: 提供低延迟、双向的实时通信接口。 +- **"一发多收"架构**: + - **发送者 (Sender)**: 单一客户端作为音频来源,向服务器持续发送音频流。 + - **接收者 (Receiver)**: 多个客户端可以订阅同一个会话,实时接收广播的识别结果。 +- **异步核心**: 基于 FastAPI 和 `asyncio` 构建,可处理大量并发连接。 +- **模块化设计**: 清晰地分离了服务层 (`server.py`)、会话管理层 (`ASRRunner`) 和核心处理流水线 (`ASRPipeline`)。 + +## 📂 项目结构 -## 项目结构 ``` . -├── src/ # 源代码目录 -│ ├── __init__.py # 包初始化文件 -│ ├── server.py # WebSocket服务器实现 -│ ├── config.py # 配置处理模块 -│ ├── models.py # 模型加载模块 -│ ├── service.py # ASR服务实现 -│ └── client.py # 测试客户端 -├── tests/ # 测试目录 -│ ├── __init__.py # 测试包初始化文件 -│ └── test_config.py # 配置模块测试 -├── requirements.txt # Python依赖 -├── Dockerfile # Docker配置 -├── docker-compose.yml # Docker Compose配置 -├── .gitignore # Git忽略文件 -└── README.md # 项目说明 +├── main.py # 应用程序主入口,使用 uvicorn 启动服务 +├── WEBSOCKET_API.md # WebSocket API 详细使用文档和示例 +├── src +│ ├── server.py # FastAPI 应用核心,管理生命周期和全局资源 +│ ├── runner +│ │ └── ASRRunner.py # 核心会话管理器,负责创建和协调识别会话 (SAR) +│ ├── pipeline +│ │ └── ASRpipeline.py # 同步的、基于线程的语音处理流水线 +│ ├── functor # VAD, ASR, SPK 等原子操作的实现 +│ ├── websockets +│ │ ├── adapter.py # WebSocket 适配器,处理数据格式转换 +│ │ ├── endpoint +│ │ │ └── asr_endpoint.py # WebSocket 的业务逻辑端点 +│ │ └── router.py # WebSocket 路由 +│ └── ... +└── tests + ├── runner + │ └── asr_runner_test.py # ASRRunner 的单元测试 (异步) + └── websocket + └── websocket_asr.py # WebSocket 服务的端到端测试 ``` -## 功能特性 +## 🚀 快速开始 -- **多模式识别**:支持离线(offline)、在线(online)和两阶段(2pass)识别模式 -- **语音活动检测**:自动检测语音开始和结束 -- **标点符号**:支持自动添加标点符号 -- **WebSocket接口**:基于二进制WebSocket提供实时语音识别 -- **Docker支持**:提供容器化部署支持 +### 1. 环境与依赖 -## 安装与使用 - -### 环境要求 - Python 3.8+ -- CUDA支持 (若需GPU加速) -- 内存 >= 8GB +- 项目依赖项记录在 `requirements.txt` 文件中。 -### 安装依赖 +### 2. 安装 +建议在虚拟环境中安装依赖。在项目根目录下,运行: ```bash pip install -r requirements.txt ``` -### 运行服务器 +### 3. 运行服务 +执行主入口文件来启动 FastAPI 服务: ```bash -python src/server.py +python main.py ``` +服务启动后,将监听 `http://0.0.0.0:8000`。 -常用启动参数: -- `--host`: 服务器监听地址,默认为 0.0.0.0 -- `--port`: 服务器端口,默认为 10095 -- `--device`: 设备类型(cuda或cpu),默认为 cuda -- `--ngpu`: GPU数量,0表示使用CPU,默认为 1 +## 💡 如何使用 -### 测试客户端 +服务通过 WebSocket 提供,客户端通过 `session_id` 来创建或加入一个识别会话,并通过 `mode` 参数声明自己的角色(`sender` 或 `receiver`)。 +**详细的 API 说明、URL 格式以及 Python 和 JavaScript 的客户端连接示例,请参阅:** + +➡️ **[WEBSOCKET_API.md](./docs/WEBSOCKET_API.md)** + +## 🔬 测试 + +项目提供了两种测试方式来验证其功能。 + +### 1. 端到端 WebSocket 测试 + +此测试会模拟一个 `sender` 和一个 `receiver`,完整地测试一次识别会话。 + +**前提**: 确保 FastAPI 服务正在运行。 ```bash -python src/client.py --audio_file path/to/audio.wav +python main.py ``` -常用客户端参数: -- `--audio_file`: 要识别的音频文件路径 -- `--mode`: 识别模式,可选 2pass/online/offline,默认为 2pass -- `--host`: 服务器地址,默认为 localhost -- `--port`: 服务器端口,默认为 10095 - -## Docker部署 - -### 构建镜像 - +在项目根目录下执行: ```bash -docker build -t funasr-websocket . +python tests/websocket/websocket_asr.py ``` -### 使用Docker Compose启动 +### 2. ASRRunner 单元测试 +此测试针对核心的 `ASRRunner` 组件进行,验证其异步逻辑。 + +执行测试: ```bash -docker-compose up -d +python test_main.py ``` -## API说明 - -### WebSocket消息格式 - -1. **客户端配置消息**: -```json -{ - "mode": "2pass", // 可选: "2pass", "online", "offline" - "chunk_size": "5,10", // 块大小,格式为"encoder_size,decoder_size" - "wav_name": "audio1", // 音频标识名称 - "is_speaking": true // 是否正在说话 -} -``` - -2. **客户端音频数据**: -二进制音频数据流,16kHz采样率,16位PCM格式 - -3. **服务器识别结果**: -```json -{ - "mode": "2pass-online", // 识别模式 - "text": "识别的文本内容", // 识别结果 - "wav_name": "audio1", // 音频标识 - "is_final": false // 是否是最终结果 -} -``` diff --git a/data/speakers.json b/data/speakers.json index 2985f53..5a2e08c 100644 --- a/data/speakers.json +++ b/data/speakers.json @@ -1,6 +1,6 @@ [ { - "speaker_id": "b7e2c8e2-1f3a-4c2a-9e7a-2c1d4e8f9a3b", + "speaker_id": "137facd6-a1c9-47b9-b87d-16e6f62e07bd", "speaker_name": "ZiyangZhang", "wav_path": "/home/lyg/Code/funasr/data/speaker_wav/ZiyangZhang.wav", "speaker_embs": [ @@ -199,7 +199,7 @@ ] }, { - "speaker_id": "b7e2c8e2-1f3a-4c2a-9e7a-2c1d4e8f9a3b", + "speaker_id": "81e1b806-c76a-468f-98b7-4a63f2996480", "speaker_name": "HaiaoDuan", "wav_path": "/home/lyg/Code/funasr/data/speaker_wav/HaiaoDuan.wav", "speaker_embs": [ diff --git a/WEBSOCKET_API.md b/docs/WEBSOCKET_API.md similarity index 93% rename from WEBSOCKET_API.md rename to docs/WEBSOCKET_API.md index cf7e97e..1b7f3de 100644 --- a/WEBSOCKET_API.md +++ b/docs/WEBSOCKET_API.md @@ -26,7 +26,7 @@ ws://:8000/ws/asr/{session_id}?mode= - **音频格式**: `sender` 必须发送原始的 **PCM 音频数据**。 - **采样率**: 16000 Hz - - **位深**: 16-bit (signed integer) + - **位深**: 32-bit (floating point) - **声道数**: 单声道 (Mono) - **传输格式**: 必须以**二进制 (bytes)** 格式发送。 - **结束信号**: 当音频流结束时,`sender` 应发送一个**文本消息** `"close"` 来通知服务器关闭会话。 @@ -64,7 +64,7 @@ import uuid SERVER_URI = "ws://localhost:8000/ws/asr/{session_id}?mode=sender" SESSION_ID = str(uuid.uuid4()) # 为这次会话生成一个唯一的ID AUDIO_FILE = "tests/XT_ZZY_denoise.wav" # 替换为你的音频文件路径 -CHUNK_SIZE = 3200 # 每次发送 100ms 的音频数据 (16000 * 2 * 0.1) +CHUNK_SIZE = 3200 # 对应 100ms 的 float32 数据 (16000 * 4 * 0.1) async def send_audio(): """连接到服务器,并流式发送音频文件""" @@ -80,7 +80,8 @@ async def send_audio(): print("开始发送音频...") while True: - data = f.read(CHUNK_SIZE, dtype='int16') + # 读取为 float32 类型 + data = f.read(CHUNK_SIZE, dtype='float32') if not data.any(): break # 将 numpy 数组转换为原始字节流 @@ -215,18 +216,14 @@ if __name__ == "__main__": audioContext = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: SAMPLE_RATE }); const source = audioContext.createMediaStreamSource(mediaStream); - const bufferSize = CHUNK_DURATION_MS * SAMPLE_RATE / 1000 * 2; // 计算缓冲区大小 + const bufferSize = CHUNK_DURATION_MS * SAMPLE_RATE / 1000 * 4; // 计算缓冲区大小 scriptProcessor = audioContext.createScriptProcessor(bufferSize, 1, 1); scriptProcessor.onaudioprocess = (e) => { if (websocket && websocket.readyState === WebSocket.OPEN) { const inputData = e.inputBuffer.getChannelData(0); - // 服务器期望16-bit PCM,需要转换 - const pcmData = new Int16Array(inputData.length); - for (let i = 0; i < inputData.length; i++) { - pcmData[i] = Math.max(-1, Math.min(1, inputData[i])) * 32767; - } - websocket.send(pcmData.buffer); + // 服务器期望 float32 数据,inputData 本身就是 Float32Array,直接发送其 buffer + websocket.send(inputData.buffer); } }; diff --git a/main.py b/main.py index ffa7a78..6cf633d 100644 --- a/main.py +++ b/main.py @@ -4,7 +4,7 @@ from src.utils.logger import get_module_logger, setup_root_logger from datetime import datetime time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") -setup_root_logger(level="INFO", log_file=f"logs/main_{time}.log") +setup_root_logger(level="DEBUG", log_file=f"logs/main_{time}.log") logger = get_module_logger(__name__) if __name__ == "__main__": @@ -14,6 +14,6 @@ if __name__ == "__main__": uvicorn.run( app, host="0.0.0.0", - port=8000, + port=11096, log_level="info" ) \ No newline at end of file diff --git a/paerser.py b/paerser.py new file mode 100644 index 0000000..80ca1dc --- /dev/null +++ b/paerser.py @@ -0,0 +1,32 @@ +def pre_remove_details(input_string: str) -> str: + start_tag = '' + start = input_string.find(start_tag, 0) + if start == -1: + return input_string, "unfind %s" % start_tag + return input_string[start + len(start_tag):], "success remove %s" % start_tag + +def pre_remove_markdown(input_string: str) -> str: + start_tag = '```markdown' + end_tag = '```' + start = input_string.find(start_tag, 0) + if start == -1: + return input_string, "unfind %s" % start_tag + end = input_string.find(end_tag, start + 11) + if end == -1: + return input_string, "unfind %s" % end_tag + return input_string[start + 11:end].strip(), "success remove %s" % start_tag + +def main(input_string: str) -> dict: + result = input_string + statuses = [] + + result, detail_status = pre_remove_details(result) + statuses.append(detail_status) + + result, markdown_status = pre_remove_markdown(result) + statuses.append(markdown_status) + + return { + "result": result, + "status": statuses + } \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 66e9708..2b28761 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,11 +1,11 @@ -pytest==7.3.1 -pytest-cov==4.1.0 -flake8==6.0.0 -black==23.3.0 -isort==5.12.0 -flask==2.3.2 -requests==2.31.0 -websockets==11.0.3 -numpy==1.24.3 -funasr==0.10.0 -modelscope==1.9.5 \ No newline at end of file +fastapi==0.115.14 +funasr==1.2.6 +modelscope==1.27.1 +numpy==2.0.1 +pyaudio==0.2.14 +pydantic==2.11.7 +pydub==0.25.1 +pytest==8.3.5 +soundfile==0.13.1 +torch==2.3.1 +uvicorn==0.35.0 diff --git a/requirements.txt.backup b/requirements.txt.backup new file mode 100644 index 0000000..66e9708 --- /dev/null +++ b/requirements.txt.backup @@ -0,0 +1,11 @@ +pytest==7.3.1 +pytest-cov==4.1.0 +flake8==6.0.0 +black==23.3.0 +isort==5.12.0 +flask==2.3.2 +requests==2.31.0 +websockets==11.0.3 +numpy==1.24.3 +funasr==0.10.0 +modelscope==1.9.5 \ No newline at end of file diff --git a/src/core/model_loader.py b/src/core/model_loader.py index 80471e2..72a5f4e 100644 --- a/src/core/model_loader.py +++ b/src/core/model_loader.py @@ -8,7 +8,7 @@ try: from funasr import AutoModel except ImportError as exc: raise ImportError("未找到funasr库, 请先安装: pip install funasr") from exc - +from modelscope.pipelines import pipeline # 日志模块 from src.utils import get_module_logger @@ -101,6 +101,16 @@ class ModelLoader: logger.error("加载%s模型失败: %s", model_type, str(e)) raise + # def _load_pipeline(self, input_model_args: dict, model_type: str): + # """ + # 加载pipeline + # """ + # default_pipeline = pipeline( + # task='speaker-verification', + # model='iic/speech_campplus_sv_zh-cn_16k-common', + # model_revision='v1.0.0' + # ) + def load_models(self, args): """ 加载所有需要的模型 @@ -115,12 +125,19 @@ class ModelLoader: self.models = {} # 加载离线ASR模型 # 检查对应键是否存在 - model_list = ["asr", "asr_online", "vad", "punc", "spk"] + model_list = ["asr", "asr_online", "vad", "punc"] for model_name in model_list: name_model = f"{model_name}_model" name_model_revision = f"{model_name}_model_revision" if name_model in args: logger.debug("加载%s模型", model_name) self.models[model_name] = self._load_model(args, model_name) - logger.info("所有模型加载完成") + pipeline_list = ["spk"] + for pipeline_name in pipeline_list: + if pipeline_name == "spk": + self.models[pipeline_name] = pipeline( + task='speaker-verification', + model='iic/speech_campplus_sv_zh-cn_16k-common', + model_revision='v1.0.0' + ) return self.models diff --git a/src/functor/base.py b/src/functor/base.py index 6436cc5..b56eb7f 100644 --- a/src/functor/base.py +++ b/src/functor/base.py @@ -17,6 +17,9 @@ from typing import Callable, List, Dict from queue import Queue import threading +from src.utils.logger import get_module_logger + +logger = get_module_logger(__name__) class BaseFunctor(ABC): """ @@ -157,13 +160,15 @@ class FunctorFactory: """ from src.functor.spk_functor import SPKFunctor + logger.debug(f"创建spk functor[开始]") audio_config = config["audio_config"] - model = {"spk": models["spk"]} + # model = {"spk": models["spk"]} - spk_functor = SPKFunctor() + spk_functor = SPKFunctor(sv_pipeline=models["spk"]) spk_functor.set_audio_config(audio_config) - spk_functor.set_model(model) + # spk_functor.set_model(model) + logger.debug(f"创建spk functor[完成]") return spk_functor def _make_resultbinderfunctor(config: dict, models: dict) -> BaseFunctor: diff --git a/src/functor/resultbinder_functor.py b/src/functor/resultbinder_functor.py index b7b33a8..a906a12 100644 --- a/src/functor/resultbinder_functor.py +++ b/src/functor/resultbinder_functor.py @@ -5,7 +5,7 @@ ResultBinderFunctor from src.functor.base import BaseFunctor from src.models import AudioBinary_Config, VAD_Functor_result -from typing import Callable, List +from typing import Callable, List, Dict, Any from queue import Queue, Empty import threading import time @@ -74,16 +74,30 @@ class ResultBinderFunctor(BaseFunctor): for callback in self._callback: callback(result) - def _process(self, data: VAD_Functor_result) -> None: + def _process(self, data: Dict[str, Any]) -> None: """ 处理数据 + { + "is_final": false, + "mode": "2pass-offline", + "text": ",等一下我回一下,ok你看这里就有了", + "wav_name": "h5", + "speaker_id": + } """ logger.debug("ResultBinderFunctor处理数据: %s", data) # 将data中的result进行聚合 # 此步暂时无意义,预留 - results = {} - for name, result in data.items(): - results[name] = result + results = { + "is_final": False, + "mode": "2pass-offline", + "text": data["asr"], + "wav_name": "h5", + "speaker_id": data["spk"]["speaker_id"] + } + + # for name, result in data.items(): + # results[name] = result self._do_callback(results) def _run(self) -> None: diff --git a/src/functor/spk_functor.py b/src/functor/spk_functor.py index bf6a0e6..bcb7df6 100644 --- a/src/functor/spk_functor.py +++ b/src/functor/spk_functor.py @@ -12,6 +12,8 @@ import torch import threading import numpy import os +import requests + # 日志 from src.utils.logger import get_module_logger @@ -61,7 +63,7 @@ class SPKFunctor(BaseFunctor): def add_speaker(self, speaker: SpeakerCreate) -> None: self._spk_data.append(speaker) - logger.debug("添加说话人: %s", speaker) + # logger.debug("添加说话人: %s", speaker) def verify(self, emb: numpy.ndarray) -> Dict: # 将输入的numpy embedding转换为tensor @@ -104,22 +106,112 @@ class SPKFunctor(BaseFunctor): "results": results } - def __init__(self) -> None: + def __init__(self, sv_pipeline: pipeline) -> None: super().__init__() # 资源与配置 self._spk_verify = self.speaker_verify() - self._sv_pipeline = pipeline( - task='speaker-verification', - model='iic/speech_campplus_sv_zh-cn_16k-common', - model_revision='v1.0.0' - ) + self._sv_pipeline = sv_pipeline self._model: dict = {} # 模型 self._callback: List[Callable] = [] # 回调函数 self._input_queue: Queue = None # 输入队列 self._audio_config: AudioBinary_Config = None # 音频配置 - logger.debug("加载本地说话人数据") - self.load_spk_data_local() + # logger.debug("加载本地说话人数据") + # self.load_spk_data_local() + # import inspect + # func_name = inspect.currentframe().f_code.co_name + # logger.info(f"{func_name} 加载数据库说话人数据") + self.load_spk_database_api(url="http://172.23.30.120:11200/api/v1/speakers/") + + def load_spk_database_api( + self, + url: str = None, + ) -> None: + """ + 加载api远程数据库说话人数据 + { + "items": [ + { + "speaker_name": "张子洋", + "speaker_description": "哈吉米1号", + "avatar": "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", + "audio_sample": "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", + "audio_feature_vector": null, + "speaker_id": "137facd6-a1c9-47b9-b87d-16e6f62e07bd", + "created_at": "2025-07-02T07:58:28.454538Z", + "updated_at": "2025-07-02T07:58:28.454538Z" + }, + { + "speaker_name": "吴兴泰", + "speaker_description": "哈吉米王", + "avatar": "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", + "audio_sample": "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", + "audio_feature_vector": null, + "speaker_id": "81e1b806-c76a-468f-98b7-4a63f2996480", + "created_at": "2025-07-02T07:59:07.192488Z", + "updated_at": "2025-07-02T07:59:07.192488Z" + } + ] +} + """ + # 网络请求后端数据库拿到所有的说话人数据 + + try: + if not url: + logger.error("未提供说话人数据库API的URL") + return + response = requests.get(url) + response.raise_for_status() + data = response.json() + items = data.get("items", []) + for spk in items: + logger.debug("加载API说话人数据: %s %s", spk.get('speaker_name'), spk.get('speaker_id')) + # 兼容API返回的字段与本地字段 + spk_dict = { + "speaker_name": spk.get("speaker_name", ""), + "speaker_id": spk.get("speaker_id", ""), + "speaker_description": spk.get("speaker_description", ""), + "avatar": spk.get("avatar", ""), + "wav_path": "", # API未提供本地wav路径 + "speaker_embs": spk.get("audio_feature_vector", []), + } + # 如果API没有embs但有音频样本,可以尝试提取 + if (not spk_dict["speaker_embs"] or spk_dict["speaker_embs"] is None) and spk.get("audio_sample"): + try: + import base64 + import io + import numpy as np + from pydub import AudioSegment + + audio_bytes = base64.b64decode(spk["audio_sample"]) + + # 使用 pydub 处理音频,它能兼容 wav, mp3 等多种格式 (需要 ffmpeg) + audio_segment = AudioSegment.from_file(io.BytesIO(audio_bytes)) + + # 将音频转换为模型期望的格式,通常是 16k 采样率、单声道 + audio_segment = audio_segment.set_frame_rate(16000) + audio_segment = audio_segment.set_channels(1) + + # 转换为 float32 的 numpy 数组并归一化 + wav_data = np.array(audio_segment.get_array_of_samples()).astype(np.float32) + wav_data /= 32768.0 # 16-bit signed audio is in range [-32768, 32767] + + spk_dict["speaker_embs"] = self._sv_pipeline([wav_data], output_emb=True)['embs'][0] + logger.debug("API音频样本转换为embs: %s", spk_dict["speaker_name"]) + except Exception: + logger.error("API音频样本 '%s' 转换为embs失败", spk_dict.get("speaker_name", "Unknown"), exc_info=True) + spk_dict["speaker_embs"] = [] + + # 转为numpy后加入 + try: + import numpy + spk_dict["speaker_embs"] = numpy.array(spk_dict["speaker_embs"]) + self._spk_verify.add_speaker(SpeakerCreate(**spk_dict)) + except Exception as e: + logger.error("添加API说话人到本地失败: %s", e) + except Exception as e: + logger.error("请求说话人数据库API失败: %s", e) + def load_spk_data_local( self, @@ -131,7 +223,7 @@ class SPKFunctor(BaseFunctor): with open(spk_data_path, 'r') as f: spk_data = json.load(f) for i, spk in enumerate(spk_data): - logger.debug("加载本地说话人数据: %s", spk) + logger.debug("加载本地说话人数据: %s %s", spk['speaker_name'], spk['speaker_id']) if spk['speaker_embs'] == "" and spk['wav_path'] != "": logger.debug("尝试转换本地wav为embs: %s", spk['wav_path']) try: @@ -148,7 +240,8 @@ class SPKFunctor(BaseFunctor): except Exception as e: logger.error("转换本地wav为embs失败: %s", e) else: - logger.debug("加载本地说话人数据: %s", spk) + pass + # logger.debug("加载本地说话人数据: %s %s", spk['speaker_name'], spk['speaker_id']) # 将spk的speaker_embs转换为numpy spk['speaker_embs'] = numpy.array(spk['speaker_embs']) self._spk_verify.add_speaker(SpeakerCreate(**spk)) @@ -187,7 +280,6 @@ class SPKFunctor(BaseFunctor): self._audio_config = audio_config logger.debug("SpkFunctor设置音频配置: %s", self._audio_config) - def add_callback(self, callback: Callable) -> None: """ 向自身的_callback: List[Callable]回调函数列表中添加回调函数 diff --git a/src/functor/vad_functor.py b/src/functor/vad_functor.py index e682439..2c9d590 100644 --- a/src/functor/vad_functor.py +++ b/src/functor/vad_functor.py @@ -7,6 +7,8 @@ import threading from queue import Empty, Queue from typing import List, Any, Callable import numpy +import time +from datetime import datetime from src.models import ( VAD_Functor_result, AudioBinary_Config, @@ -126,7 +128,10 @@ class VADFunctor(BaseFunctor): self._cache_result_list[-1][1] = end else: self._cache_result_list.append(pair) - while len(self._cache_result_list) > 1: + logger.debug(f"VADFunctor结果: {self._cache_result_list}") + while len(self._cache_result_list) > 0 and self._cache_result_list[0][1] != -1: + logger.debug(f"VADFunctor结果: {self._cache_result_list}") + logger.debug(f"VADFunctor list[0][1]: {self._cache_result_list[0][1]}") # 创建VAD片段 # 计算开始帧 start_frame = self._audio_config.ms2frame(self._cache_result_list[0][0]) @@ -135,12 +140,16 @@ class VADFunctor(BaseFunctor): end_frame = self._audio_config.ms2frame(self._cache_result_list[0][1]) end_frame -= self._audio_cache_preindex # 计算开始时间 + timestamp = time.time() + format_time = datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S') + logger.debug(f"{format_time}创建VAD片段: {start_frame} - {end_frame}") vad_result = VAD_Functor_result.create_from_push_data( audiobinary_data_list=self._audio_binary_data_list, data=self._audiobinary_cache[start_frame:end_frame], start_time=self._cache_result_list[0][0], end_time=self._cache_result_list[0][1], ) + logger.debug(f"{format_time}创建VAD片段成功: {vad_result}") self._audio_cache_preindex += end_frame self._audiobinary_cache = self._audiobinary_cache[end_frame:] for callback in self._callback: diff --git a/src/pipeline/ASRpipeline.py b/src/pipeline/ASRpipeline.py index f1f1c06..399bd23 100644 --- a/src/pipeline/ASRpipeline.py +++ b/src/pipeline/ASRpipeline.py @@ -108,16 +108,19 @@ class ASRPipeline(PipelineBase): from src.functor import FunctorFactory # 加载VAD、asr、spk functor + logger.debug(f"使用FunctorFactory创建vad functor") self._functor_dict["vad"] = FunctorFactory.make_functor( functor_name="vad", config=self._config, models=self._models ) + logger.debug(f"使用FunctorFactory创建asr functor") self._functor_dict["asr"] = FunctorFactory.make_functor( functor_name="asr", config=self._config, models=self._models ) + logger.debug(f"使用FunctorFactory创建spk functor") self._functor_dict["spk"] = FunctorFactory.make_functor( functor_name="spk", config=self._config, models=self._models ) - + logger.debug(f"使用FunctorFactory创建resultbinder functor") self._functor_dict["resultbinder"] = FunctorFactory.make_functor( functor_name="resultbinder", config=self._config, models=self._models ) @@ -160,8 +163,10 @@ class ASRPipeline(PipelineBase): # 设置resultbinder的回调函数 为 自身被设置的回调函数,用于和外界交互 self._functor_dict["resultbinder"].add_callback(self._callback) - except ImportError: - raise ImportError("functorFactory引入失败,ASRPipeline无法完成初始化") + except ImportError as e: + raise ImportError(f"functorFactory引入失败,ASRPipeline无法完成初始化: {str(e)}") + except Exception as e: + raise Exception(f"ASRPipeline初始化失败: {str(e)}") def _check_result(self, result: Any) -> None: """ diff --git a/src/websockets/adapter.py b/src/websockets/adapter.py index 053d4c0..31e4a8e 100644 --- a/src/websockets/adapter.py +++ b/src/websockets/adapter.py @@ -25,8 +25,11 @@ class FastAPIWebSocketAdapter: message = await self._ws.receive() if 'bytes' in message: bytes_data = message['bytes'] - # 将字节流转换为float64的Numpy数组 - audio_array = np.frombuffer(bytes_data, dtype=np.float32) + audio_array = np.frombuffer(bytes_data, dtype=np.int16) + # 将int16转为float32 + audio_array = audio_array.astype(np.float32) + # 归一化 + audio_array = audio_array / 32768.0 # 使用回车符 \r 覆盖打印进度 self._total_received += len(bytes_data) diff --git a/tests/runner/asr_runner_test.py b/tests/runner/asr_runner_test.py index 79e047c..00fd866 100644 --- a/tests/runner/asr_runner_test.py +++ b/tests/runner/asr_runner_test.py @@ -65,7 +65,7 @@ async def test_asr_runner(): } models = model_loader.load_models(args) audio_file_path = "tests/XT_ZZY_denoise.wav" - audio_data, sample_rate = soundfile.read(audio_file_path) + audio_data, sample_rate = soundfile.read(audio_file_path, dtype='float32') logger.info( f"加载数据: {audio_file_path} , audio_data_length: {len(audio_data)}, audio_data_type: {type(audio_data)}, sample_rate: {sample_rate}" ) @@ -112,7 +112,7 @@ async def test_asr_runner(): # 每次发送100ms的音频 audio_clip_len = int(sample_rate * 0.1) for i in range(0, len(audio_data), audio_clip_len): - chunk = audio_data[i : i + audio_clip_len] + chunk = audio_data[i : i + audio_clip_len].astype(np.float32) if chunk.size == 0: break mock_ws.put_for_recv(chunk) diff --git a/tests/websocket/websocket_asr.py b/tests/websocket/websocket_asr.py index a54336e..6157e77 100644 --- a/tests/websocket/websocket_asr.py +++ b/tests/websocket/websocket_asr.py @@ -5,7 +5,7 @@ import uuid # --- 配置 --- HOST = "localhost" -PORT = 8000 +PORT = 11096 SESSION_ID = str(uuid.uuid4()) SENDER_URI = f"ws://{HOST}:{PORT}/ws/asr/{SESSION_ID}?mode=sender" RECEIVER_URI = f"ws://{HOST}:{PORT}/ws/asr/{SESSION_ID}?mode=receiver" @@ -54,7 +54,7 @@ async def run_sender(): # --- 主任务:发送音频 --- try: print("▶️ [Sender] 准备发送音频...") - audio_data, sample_rate = sf.read(AUDIO_FILE_PATH, dtype='float32') + audio_data, sample_rate = sf.read(AUDIO_FILE_PATH, dtype='int16') if sample_rate != 16000: print(f"❌ [Sender] 错误:音频文件采样率必须是 16kHz。") receiver_sub_task.cancel()