实时语音识别器/python

最新推荐文章于 2025-04-11 20:43:45 发布
adfass
最新推荐文章于 2025-04-11 20:43:45 发布
阅读量96
点赞数 2
文章标签：语音识别 python 人工智能
本文链接：https://blog.youkuaiyun.com/adfass/article/details/146536337
版权
import sys
import pyaudio
import threading
import websocket
import uuid
import json
import logging
import configparser
import traceback
import time
from queue import Queue
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QTextEdit, QPushButton
from PyQt5.QtCore import pyqtSignal, QObject, QTimer

# 配置日志
logging.basicConfig(
    format='[%(asctime)-15s] [%(funcName)s()][%(levelname)s] %(message)s',
    level=logging.INFO
)

# 读取配置文件
config = configparser.ConfigParser()
config.read('config.ini')
URI = config.get('baidu_speech', 'uri')
APP_ID = config.getint('baidu_speech', 'app_id')
APP_KEY = config.get('baidu_speech', 'app_key')
DEV_PID = config.getint('baidu_speech', 'dev_pid')

# 全局常量
AUDIO_FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
CHUNK = 1024
MAX_RECONNECT_ATTEMPTS = 3
RECONNECT_DELAY = 1


class SignalEmitter(QObject):
    result_received = pyqtSignal(str)
    status_updated = pyqtSignal(str)


class SpeechToTextWidget(QWidget):
    def __init__(self):
        super().__init__()

        # 初始化变量
        self.p = pyaudio.PyAudio()
        self.stream = None
        self.is_recording = False
        self.websocket_app = None
        self.audio_queue = Queue(maxsize=100)
        self.reconnect_attempts = 0
        self.websocket_connected = threading.Event()

        # 初始化UI
        self.init_ui()

        # 信号连接
        self.signal_emitter = SignalEmitter()
        self.signal_emitter.result_received.connect(self.update_text_edit)
        self.signal_emitter.status_updated.connect(self.update_status)

        # 定时器用于处理音频队列
        self.timer = QTimer()
        self.timer.timeout.connect(self.process_audio_queue)
        self.timer.start(50)  # 每50ms处理一次队列

    def init_ui(self):
        layout = QVBoxLayout()

        self.text_edit = QTextEdit()
        self.text_edit.setReadOnly(True)
        layout.addWidget(self.text_edit)

        self.status_label = QTextEdit()
        self.status_label.setReadOnly(True)
        self.status_label.setMaximumHeight(60)
        layout.addWidget(self.status_label)

        self.start_button = QPushButton('开始识别')
        self.start_button.clicked.connect(self.toggle_recognition)
        layout.addWidget(self.start_button)

        self.setLayout(layout)
        self.setWindowTitle('实时语音转文字')
        self.resize(600, 400)
        self.show()

    def toggle_recognition(self):
        if not self.is_recording:
            self.start_recognition()
        else:
            self.stop_recognition()

    def start_recognition(self):
        self.is_recording = True
        self.start_button.setText('停止识别')
        self.text_edit.clear()
        self.status_label.clear()

        # 先建立WebSocket连接
        self.connect_websocket()

        # 等待连接建立或超时
        if not self.websocket_connected.wait(timeout=5):
            self.signal_emitter.status_updated.emit("连接超时，请重试")
            self.is_recording = False
            self.start_button.setText('开始识别')
            return

        # 启动录音线程
        self.recording_thread = threading.Thread(
            target=self.record_audio,
            daemon=True
        )
        self.recording_thread.start()

        self.signal_emitter.status_updated.emit("正在录音...")

    def stop_recognition(self):
        self.is_recording = False
        self.start_button.setText('开始识别')

        # 停止录音
        self._close_audio_stream()

        # 发送结束消息
        self.send_finish()

        # 关闭WebSocket
        self._close_websocket()

        self.signal_emitter.status_updated.emit("已停止")

    def connect_websocket(self):
        def on_open(ws):
            self.reconnect_attempts = 0
            self.websocket_connected.set()
            self.send_start_params()
            self.signal_emitter.status_updated.emit("连接已建立")

        def on_message(ws, message):
            try:
                data = json.loads(message)
                if data.get("type") == "FIN_TEXT" and "result" in data:
                    self.signal_emitter.result_received.emit(data['result'])
                elif data.get("type") == "MID_TEXT" and "result" in data:
                    self.signal_emitter.result_received.emit(data['result'] + "...")
            except json.JSONDecodeError as e:
                logging.error(f"JSON解析错误: {e}, 原始消息: {message}")

        def on_error(ws, error):
            logging.error(f"WebSocket错误: {error}")
            if "连接" in str(error) and self.reconnect_attempts < MAX_RECONNECT_ATTEMPTS:
                self.reconnect_attempts += 1
                time.sleep(RECONNECT_DELAY)
                self.signal_emitter.status_updated.emit(
                    f"尝试重新连接({self.reconnect_attempts}/{MAX_RECONNECT_ATTEMPTS})...")
                self.connect_websocket()

        def on_close(ws, close_status_code, close_msg):
            self.websocket_connected.clear()
            logging.info(f"连接关闭: 状态码={close_status_code}, 消息={close_msg}")
            if self.is_recording:
                self.signal_emitter.status_updated.emit("连接断开，尝试重新连接...")
                self.connect_websocket()

        uri = URI + "?sn=" + str(uuid.uuid1())
        self.websocket_app = websocket.WebSocketApp(
            uri,
            on_open=on_open,
            on_message=on_message,
            on_error=on_error,
            on_close=on_close
        )

        # 启动WebSocket线程
        self.ws_thread = threading.Thread(
            target=self.websocket_app.run_forever,
            daemon=True
        )
        self.ws_thread.start()

    def record_audio(self):
        def callback(in_data, frame_count, time_info, status):
            if self.is_recording:
                self.audio_queue.put(in_data)
            return (None, pyaudio.paContinue)

        try:
            self.stream = self.p.open(
                format=AUDIO_FORMAT,
                channels=CHANNELS,
                rate=RATE,
                input=True,
                frames_per_buffer=CHUNK,
                stream_callback=callback
            )
            self.stream.start_stream()
            logging.info("音频流已启动")
        except Exception as e:
            logging.error(f"打开音频流失败: {e}")
            self.signal_emitter.status_updated.emit("无法访问麦克风")
            self.is_recording = False
            self.start_button.setText('开始识别')

    def process_audio_queue(self):
        if not self.is_recording or not self.websocket_connected.is_set():
            return

        try:
            while not self.audio_queue.empty():
                data = self.audio_queue.get_nowait()
                self._send_ws_message(data, websocket.ABNF.OPCODE_BINARY)
        except Exception as e:
            logging.error(f"处理音频队列错误: {e}")

    def send_start_params(self):
        req = {
            "type": "START",
            "data": {
                "appid": APP_ID,
                "appkey": APP_KEY,
                "dev_pid": DEV_PID,
                "cuid": str(uuid.uuid1()),
                "sample": RATE,
                "format": "pcm"
            }
        }
        self._send_ws_message(json.dumps(req), websocket.ABNF.OPCODE_TEXT)

    def send_finish(self):
        req = {"type": "FINISH"}
        self._send_ws_message(json.dumps(req), websocket.ABNF.OPCODE_TEXT)

    def update_text_edit(self, result):
        self.text_edit.append(result)

    def update_status(self, message):
        self.status_label.append(message)

    def _send_ws_message(self, message, opcode):
        try:
            if (self.websocket_app and
                    hasattr(self.websocket_app, 'sock') and
                    self.websocket_app.sock and
                    self.websocket_app.sock.connected):

                self.websocket_app.send(message, opcode)
                if isinstance(message, str):
                    logging.debug(f"发送消息: {message}")
            else:
                logging.warning("无法发送消息: WebSocket未连接")
        except Exception as e:
            logging.error(f"发送消息失败: {e}")

    def _close_audio_stream(self):
        if self.stream:
            try:
                if self.stream.is_active():
                    self.stream.stop_stream()
                self.stream.close()
                logging.info("音频流已关闭")
            except Exception as e:
                logging.error(f"关闭音频流失败: {e}")
            finally:
                self.stream = None

    def _close_websocket(self):
        if self.websocket_app:
            try:
                self.websocket_app.close()
                logging.info("WebSocket连接已关闭")
            except Exception as e:
                logging.error(f"关闭WebSocket失败: {e}")
            finally:
                self.websocket_app = None
                self.websocket_connected.clear()

    def closeEvent(self, event):
        self.is_recording = False
        self.timer.stop()
        self._close_audio_stream()
        self._close_websocket()
        self.p.terminate()
        event.accept()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    try:
        widget = SpeechToTextWidget()
        sys.exit(app.exec_())
    except Exception as e:
        logging.error(f"程序异常: {e}")
        logging.error(traceback.format_exc())