语音识别_模拟AI(三)

一、AI模拟功能需求

1 功能概述

模拟AI进行语音对话，实现语音控制软件进行交互功能。

2 详细说明

自定义语音助手名称，类似小爱、小度等。（数据库存储）

2.1 语音助手功能

1. 软件启动后，默认启动识别功能

2. 识别到呼唤助手名称，语音播报进行回复（我在）

3. 识别到口呼常用语后，根据内容进行语音回复或进行内容播报

2.2 设计说明

2.2.1 数据库

• 口呼常用语存储本地数据库，包括语音助手的名称

• 回复的内容存储本地数据库

2.2.2 交互实现

• 识别到内容与数据库中第一条一致，语音回复数据库第一条内容 我在

• 识别到内容与数据库中其它内容一致，语音回复数据库中对应ID的内容

二、数据库内容

识别数据库内容		回复数据库内容
序号	内容		序号	内容
0	小度小度		0	我在
1	调车白灯-8		1	调车白灯
2	负载断开		2	负载断开
3	进路开通 8		3	进路开通
4	母线重联、负载断开		4	母线重联、负载断开
5	注意进站		5	注意进站
6	开左侧门		6	开左侧门
7	欢迎您乘坐5号线列车		7	欢迎您乘坐5号线列车
8	列车运行前方是北京站，请下车的乘客做好准备		8	列车运行前方是北京站，请下车的乘客做好准备
9	列车运行前方是本次列车的终点站北京站，请您做好准备。感谢您乘坐本次列车，再见		9	列车运行前方是本次列车的终点站北京站，请您做好准备。感谢您乘坐本次列车，再见
10	各位乘客，为保证正点运营，请您不要挤靠车门，以免影响正常发车，谢谢合作		10	各位乘客，为保证正点运营，请您不要挤靠车门，以免影响正常发车，谢谢合作
11	各位乘客您好，列车现在关门，上不去车的乘客，请您等候下次列车，谢谢您的支持与合作		11	各位乘客您好，列车现在关门，上不去车的乘客，请您等候下次列车，谢谢您的支持与合作
12	各位乘客您好，现在是高峰时间，乘客较多，请您配合我们抓紧时间上、下车，谢谢您的合作		12	各位乘客您好，现在是高峰时间，乘客较多，请您配合我们抓紧时间上、下车，谢谢您的合作
13	各位乘客您好，列车自动广播系统发生故障，给您带来的不便，敬请谅解		13	各位乘客您好，列车自动广播系统发生故障，给您带来的不便，敬请谅解

三、数据库实现

1、启动mysql

用户密码：还是我的常用密码

PS D:\ASR\pocketsphinx> mysql --version
D:\DevelopmentTools\Mysql\mysql-5.7.24-winx64\bin\mysql.exe  Ver 14.14 Distrib 5.7.24, for Win64 (x86_64)

PS D:\ASR\pocketsphinx> net start mysql
请求的服务已经启动。

请键入 NET HELPMSG 2182 以获得更多的帮助。

PS D:\ASR\pocketsphinx> mysql -u root -p
Enter password: **************

2、MySQL 数据库配置与插入中文数据

在 MySQL 中，插入中文数据需要确保数据库和表的字符集设置为支持中文的字符集（如 utf8mb4）。以下是创建数据库和表结构以及插入中文数据的正确方法。

1. 创建数据库和表结构

-- 创建数据库并设置字符集
CREATE DATABASE VoiceAssistant CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- 使用创建的数据库
USE VoiceAssistant;

-- 创建识别内容表
CREATE TABLE RecognizeContent (
    id INT AUTO_INCREMENT PRIMARY KEY,
    content VARCHAR(255) CHARACTER SET utf8mb4 NOT NULL
);

-- 创建回复内容表
CREATE TABLE ReplyContent (
    id INT AUTO_INCREMENT PRIMARY KEY,
    content VARCHAR(255) CHARACTER SET utf8mb4 NOT NULL
);

2. 插入数据

-- 插入识别内容
INSERT INTO RecognizeContent (content) VALUES
('小度小度'), 
('调车白灯'), 
('负载断开'), 
('进路开通'), 
('母线重联、负载断开'), 
('注意进站'), 
('开左侧门'), 
('欢迎您乘坐5号线列车'), 
('列车运行前方是北京站，请下车的乘客做好准备'), 
('列车运行前方是本次列车的终点站北京站，请您做好准备。感谢您乘坐本次列车，再见'), 
('各位乘客，为保证正点运营，请您不要挤靠车门，以免影响正常发车，谢谢合作'), 
('各位乘客您好，列车现在关门，上不去车的乘客，请您等候下次列车，谢谢您的支持与合作'), 
('各位乘客您好，现在是高峰时间，乘客较多，请您配合我们抓紧时间上、下车，谢谢您的合作'), 
('各位乘客您好，列车自动广播系统发生故障，给您带来的不便，敬请谅解');

-- 插入回复内容
INSERT INTO ReplyContent (content) VALUES
('我在'), 
('调车白灯'), 
('负载断开'), 
('进路开通'), 
('母线重联、负载断开'), 
('注意进站'), 
('开左侧门'), 
('欢迎您乘坐5号线列车'), 
('列车运行前方是北京站，请下车的乘客做好准备'), 
('列车运行前方是本次列车的终点站北京站，请您做好准备。感谢您乘坐本次列车，再见'), 
('各位乘客，为保证正点运营，请您不要挤靠车门，以免影响正常发车，谢谢合作'), 
('各位乘客您好，列车现在关门，上不去车的乘客，请您等候下次列车，谢谢您的支持与合作'), 
('各位乘客您好，现在是高峰时间，乘客较多，请您配合我们抓紧时间上、下车，谢谢您的合作'), 
('各位乘客您好，列车自动广播系统发生故障，给您带来的不便，敬请谅解');

语音播报

#include <sapi.h>
#include <string>

// 使用Windows TTS进行语音播报
void speak(const std::string& text) {
    ISpVoice* pVoice = NULL;

    if (FAILED(::CoInitialize(NULL)))
        return;

    HRESULT hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice, (void **)&pVoice);
    if (SUCCEEDED(hr)) {
        std::wstring wtext(text.begin(), text.end());
        hr = pVoice->Speak(wtext.c_str(), 0, NULL);
        pVoice->Release();
        pVoice = NULL;
    }
    ::CoUninitialize();
}

四、初始语言识别代码

将应用pocketsphinx,portaudio技术的语言识别代码替换到新项目AIVoiceAssistant中，作为项目修改的原始代码

代码主要在dlg.g，dlg.cpp，以及项目配置

VC++目录 的 包含目录
D:\DevelopmentTools\vcpkg\packages\portaudio_x64-windows\include
D:\ASR\pocketsphinx\include
D:\ASR\sphinxbase\include\win32
D:\ASR\sphinxbase\include

VC++目录的库目录
D:\DevelopmentTools\vcpkg\packages\portaudio_x64-windows\lib
D:\ASR\pocketsphinx\bin\Debug\x64
D:\ASR\sphinxbase\bin\Debug\x64

链接器输入的附加依赖项
sphinxbase.lib
pocketsphinx.lib
portaudio.lib

链接器常规的附加库目录
D:\DevelopmentTools\vcpkg\packages\portaudio_x64-windows\lib
D:\ASR\pocketsphinx\bin\Debug\x64
D:\ASR\sphinxbase\bin\Debug\x64

还需要将sphinxbase.dll，pocketsphinx.dll，portaudio.dll复制文件放在代码路径下（存放编写代码的文件夹中）

// AIVoiceAssistantDlg.h: 头文件
//

#pragma once


// 包含必要的头文件
#include <portaudio.h>       // PortAudio 库头文件，用于音频输入输出
#include <pocketsphinx.h>    // PocketSphinx 库头文件，用于语音识别
#include <sphinxbase/ad.h>   // SphinxBase 库头文件，用于音频录制
#include <sphinxbase/err.h>  // SphinxBase 库头文件，用于错误处理
#include <fstream>           // 文件操作头文件
#include <string>            // 字符串处理头文件
#include <set>               // 集合容器头文件
#include <atlstr.h>          // ATL 字符串类头文件

#include <thread>            // 线程库头文件
#include <vector>            // 向量容器头文件
#include <algorithm>         // 算法头文件
#include <locale>            // 本地化头文件
#include <codecvt>           // 编码转换头文件

#include <iostream>          // 输入输出流头文件


#define TIMER_ID 999 // 定义定时器 ID

// CAIVoiceAssistantDlg 对话框
class CAIVoiceAssistantDlg : public CDialogEx
{
// 构造
public:
	CAIVoiceAssistantDlg(CWnd* pParent = nullptr);	// 标准构造函数

// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_AIVOICEASSISTANT_DIALOG };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV 支持


// 实现
protected:
	HICON m_hIcon;

	// 生成的消息映射函数
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	afx_msg void OnDestroy();
	DECLARE_MESSAGE_MAP()
public:
	CEdit m_edtText;
	afx_msg void OnBnClickedButtonStart();
	afx_msg void OnBnClickedButtonStop();
	afx_msg void OnTimer(UINT_PTR nIDEvent); // 定时器处理函数

public:
	std::vector<int16> m_audioBuffer;   // 用于存储音频数据
	bool m_bListening = false;			// 语音识别信号
	cmd_ln_t* m_config = nullptr;		// 配置参数指针
	ps_decoder_t* m_ps = nullptr;		// PocketSphinx 解码器指针
	ad_rec_t* m_ad = nullptr;			// 音频录制指针
	uint8 utt_started = FALSE;			// 标志是否开始录制

	PaStream* m_stream = nullptr;		// PortAudio 流指针


	void RecordAudio();
	void ProcessRecordedAudio();
	void ProcessAudioFile(const std::string& filePath);
	CString ExtractTextFromHyp(const char* hyp);


private:
	std::thread m_thread; // 用于音频录制和处理的线程
};

// AIVoiceAssistantDlg.cpp: 实现文件
//

#include "pch.h"
#include "framework.h"
#include "AIVoiceAssistant.h"
#include "AIVoiceAssistantDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// PortAudio 参数
#define SAMPLE_RATE 16000
#define FRAMES_PER_BUFFER (2048) // 调整缓冲区大小

static int paCallback(const void* inputBuffer, void* outputBuffer,
	unsigned long framesPerBuffer,
	const PaStreamCallbackTimeInfo* timeInfo,
	PaStreamCallbackFlags statusFlags,
	void* userData)
{
	float* in = (float*)inputBuffer;
	float* monoBuffer = (float*)userData;

	if (inputBuffer == NULL)
	{
		return paContinue;
	}

	for (unsigned long i = 0; i < framesPerBuffer; ++i) {
		monoBuffer[i] = (in[i * 2] + in[i * 2 + 1]) * 0.5f; // 双声道转单声道
	}

	return paContinue;
}

// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_ABOUTBOX };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CAIVoiceAssistantDlg 对话框



CAIVoiceAssistantDlg::CAIVoiceAssistantDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_AIVOICEASSISTANT_DIALOG, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_config = cmd_ln_init(NULL, ps_args(), TRUE,
		"-hmm", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\zh-cn",
		"-lm", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\zh-cn.lm.bin",
		"-dict", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\zh-cn.dic",
		/*       "-hmm", "D:\\ASR\\pocketsphinx\\model\\en-us\\en-us",
			   "-lm", "D:\\ASR\\pocketsphinx\\model\\en-us\\en-us.lm.bin",
			   "-dict", "D:\\ASR\\pocketsphinx\\model\\en-us\\cmudict-en-us.dict",*/
		NULL);
	if (m_config == NULL)
	{
		AfxMessageBox(_T("1、m_config fail"));
		cmd_ln_free_r(m_config);
	}
	else
	{
		AfxMessageBox(_T("1、m_config success"));
	}

	m_ps = ps_init(m_config);
	if (m_ps == NULL)
	{
		AfxMessageBox(_T("2、m_ps fail"));
	}
	else
	{
		AfxMessageBox(_T("2、m_ps success"));
	}

	if ((m_ad = ad_open_dev("sysdefault", (int)48000)) == NULL)
	{
		AfxMessageBox(_T("3、Failed to open audio device"));
	}
	else
	{
		AfxMessageBox(_T("3、Success to open audio device"));
	}
}

void CAIVoiceAssistantDlg::OnDestroy()
{
	// 音频设备
	if (m_ad)
	{
		ad_close(m_ad);
		m_ad = nullptr;
	}

	// 释放解码器
	if (m_ps)
	{
		ps_free(m_ps);
		m_ps = nullptr;
	}

	// 释放配置参数
	if (m_config)
	{
		cmd_ln_free_r(m_config);
		m_config = nullptr;
	}
}

void CAIVoiceAssistantDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT_TEXT, m_edtText);
}

BEGIN_MESSAGE_MAP(CAIVoiceAssistantDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON_START, &CAIVoiceAssistantDlg::OnBnClickedButtonStart)
	ON_BN_CLICKED(IDC_BUTTON_STOP, &CAIVoiceAssistantDlg::OnBnClickedButtonStop)
	ON_WM_DESTROY()
	ON_WM_TIMER()
END_MESSAGE_MAP()


// CAIVoiceAssistantDlg 消息处理程序

BOOL CAIVoiceAssistantDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 将“关于...”菜单项添加到系统菜单中。

	// IDM_ABOUTBOX 必须在系统命令范围内。
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != nullptr)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标

	// TODO: 在此添加额外的初始化代码
	m_bListening = false;

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CAIVoiceAssistantDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CAIVoiceAssistantDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 用于绘制的设备上下文

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 使图标在工作区矩形中居中
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 绘制图标
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CAIVoiceAssistantDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}



void CAIVoiceAssistantDlg::OnBnClickedButtonStart()
{
	// 清空音频缓冲区
	m_audioBuffer.clear();

	// 初始化 PortAudio
	PaError err = Pa_Initialize();
	if (err != paNoError)
	{
		AfxMessageBox(_T("Failed to initialize PortAudio."));
		return;
	}

	// 设置音频流参数
	PaStreamParameters inputParameters;
	inputParameters.device = Pa_GetDefaultInputDevice(); // 获取默认输入设备
	if (inputParameters.device == paNoDevice)
	{
		AfxMessageBox(_T("No default input device."));
		Pa_Terminate();
		return;
	}
	inputParameters.channelCount = 2; // 双声道
	inputParameters.sampleFormat = paInt16; // 16 位整数
	inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency;
	inputParameters.hostApiSpecificStreamInfo = nullptr;

	// 打开音频流
	err = Pa_OpenStream(
		&m_stream,
		&inputParameters,
		nullptr, // 没有输出
		48000, // 采样率
		2048, // 缓冲区大小
		paClipOff, // 禁用剪切
		nullptr, // 没有回调
		nullptr  // 没有用户数据
	);

	if (err != paNoError)
	{
		CString errorMsg;
		errorMsg.Format(_T("Failed to open PortAudio stream: %s"), Pa_GetErrorText(err));
		AfxMessageBox(errorMsg);
		Pa_Terminate();
		return;
	}

	// 启动音频流
	if (Pa_StartStream(m_stream) != paNoError)
	{
		AfxMessageBox(_T("Failed to start PortAudio stream."));
		Pa_CloseStream(m_stream);
		Pa_Terminate();
		return;
	}

	// 设置标志以启动录音
	m_bListening = true;

	AfxMessageBox(_T("Recording started. Please speak now..."));

	// 启动录音线程
	std::thread t(&CAIVoiceAssistantDlg::RecordAudio, this);
	t.detach();  // 分离线程

	// 设置定时器，在15秒后停止录音
	SetTimer(TIMER_ID, 15000, NULL);
}


void CAIVoiceAssistantDlg::OnBnClickedButtonStop()
{
	// 停止录音
	m_bListening = false;

	// 停止定时器
	KillTimer(TIMER_ID);


	// 停止 PortAudio 流
	if (m_stream)
	{
		Pa_StopStream(m_stream);
		Pa_CloseStream(m_stream);
		Pa_Terminate();
	}

	// 提示用户停止录音
	AfxMessageBox(_T("Recording stopped. Processing data..."));

	// 处理录音数据
	ProcessRecordedAudio();
}

void CAIVoiceAssistantDlg::RecordAudio()
{
	ps_start_utt(m_ps);
	int16_t stereoBuffer[2048 * 2];

	while (m_bListening)
	{
		PaError err = Pa_ReadStream(m_stream, stereoBuffer, 2048);
		if (err != paNoError)
		{
			CString errorMsg;
			int len = MultiByteToWideChar(CP_ACP, 0, Pa_GetErrorText(err), -1, NULL, 0);
			if (len > 0)
			{
				WCHAR* wcsErrorText = new WCHAR[len];
				MultiByteToWideChar(CP_ACP, 0, Pa_GetErrorText(err), -1, wcsErrorText, len);
				errorMsg.Format(_T("Failed to read audio: %s"), wcsErrorText);
				delete[] wcsErrorText;
			}
			else
			{
				errorMsg = _T("Failed to read audio: Unknown error");
			}
			AfxMessageBox(errorMsg);
			break;
		}

		// 将双声道数据转换为单声道数据，并添加到缓冲区
		std::vector<int16_t> monoBuffer(2048);
		for (unsigned long i = 0; i < 2048; ++i)
		{
			monoBuffer[i] = (stereoBuffer[i * 2] + stereoBuffer[i * 2 + 1]) / 2; // 简单平均以获得单声道数据
		}

		// 将单声道数据添加到缓冲区
		m_audioBuffer.insert(m_audioBuffer.end(), monoBuffer.begin(), monoBuffer.end());
		ps_process_raw(m_ps, monoBuffer.data(), monoBuffer.size(), FALSE, FALSE);
	}

	ps_end_utt(m_ps);

	// 停止音频流
	Pa_StopStream(m_stream);
	Pa_CloseStream(m_stream);
	Pa_Terminate();
}


void CAIVoiceAssistantDlg::OnTimer(UINT_PTR nIDEvent)
{
	if (nIDEvent == TIMER_ID)
	{
		// 停止录音
		m_bListening = false;

		// 处理录音数据
		ProcessRecordedAudio();

		// 停止定时器
		KillTimer(TIMER_ID);
	}

	CDialogEx::OnTimer(nIDEvent);
}

void CAIVoiceAssistantDlg::ProcessRecordedAudio()
{
	if (m_audioBuffer.empty())
	{
		m_edtText.SetWindowText(_T("No audio data to process."));
		return;
	}

	// 确保 PocketSphinx 正确初始化
	if (!m_ps)
	{
		m_edtText.SetWindowText(_T("PocketSphinx not initialized."));
		return;
	}

	// 开始语音识别
	ps_start_utt(m_ps);

	// 处理音频数据
	ps_process_raw(m_ps, m_audioBuffer.data(), m_audioBuffer.size(), FALSE, FALSE);

	// 结束语音识别
	ps_end_utt(m_ps);

	const char* hyp = ps_get_hyp(m_ps, NULL);
	if (hyp != NULL)
	{
		// 将 UTF-8 编码的字符串转换为宽字符字符串
		int len = MultiByteToWideChar(CP_UTF8, 0, hyp, -1, NULL, 0);
		if (len > 0)
		{
			std::wstring wstr(len, L'\0');
			MultiByteToWideChar(CP_UTF8, 0, hyp, -1, &wstr[0], len);
			CString result(wstr.c_str());

			m_edtText.SetWindowText(result);
		}
		else
		{
			m_edtText.SetWindowText(_T("Failed to convert recognition result."));
		}
	}
	else
	{
		m_edtText.SetWindowText(_T("No result detected"));
	}
}

CString CAIVoiceAssistantDlg::ExtractTextFromHyp(const char* hyp)
{
	return CString(hyp);
}



void CAIVoiceAssistantDlg::ProcessAudioFile(const std::string& filePath)
{
	std::ifstream file(filePath, std::ios::binary);
	if (!file.is_open())
	{
		AfxMessageBox(_T("Failed to open audio file."));
		return;
	}

	// 读取文件内容到缓冲区
	std::vector<int16> audioData((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
	file.close();

	if (audioData.empty())
	{
		AfxMessageBox(_T("No audio data read from file."));
		return;
	}

	// 确保 PocketSphinx 正确初始化
	if (!m_ps)
	{
		AfxMessageBox(_T("PocketSphinx not initialized."));
		return;
	}

	// 开始语音识别
	ps_start_utt(m_ps);

	// 处理音频数据
	ps_process_raw(m_ps, audioData.data(), audioData.size() * sizeof(int16), FALSE, FALSE);

	// 结束语音识别
	ps_end_utt(m_ps);

	const char* hyp = ps_get_hyp(m_ps, NULL);
	if (hyp != NULL)
	{
		CString result = CString(hyp);
		m_edtText.SetWindowText(result);
	}
	else
	{
		m_edtText.SetWindowText(_T("No result detected"));
	}
}

五、连接MYSQL数据库

Visual Studio 2019连接MySQL数据库详细教程_visual studio服务器资源管理器 数据连接-CSDN博客

void CAIVoiceAssistantDlg::connectToDatabase()
{
	MYSQL* conn;
	MYSQL_RES* res;
	MYSQL_ROW row;

	const char* server = "localhost";
	const char* user = "root";
	const char* password = "password"; // 请替换为您的 MySQL 密码
	const char* database = "VoiceAssistant";

	conn = mysql_init(NULL);

	// 连接数据库
	if (mysql_real_connect(conn, server, user, password, database, 0, NULL, 0) == NULL)
	{
		AfxMessageBox(_T("mysql_real_connect() failed"));
		mysql_close(conn);
		return;
	}
	else
	{
		AfxMessageBox(_T("mysql_real_connect() success"));
	}
	if (mysql_set_character_set(conn, "utf8mb4"))	// 设置连接的字符集
	{
		AfxMessageBox(_T("mysql_set_character_set() failed"));
	}
	else
	{
		AfxMessageBox(_T("mysql is utf8mb4"));
	}


	// 执行查询
	if (mysql_query(conn, "SELECT * FROM RecognizeContent"))
	{
		AfxMessageBox(_T("SELECT * FROM RecognizeContent failed"));
		mysql_close(conn);
		return;
	}
	else
	{
		AfxMessageBox(_T("SELECT * FROM RecognizeContent success"));
	}

	res = mysql_store_result(conn);

	if (res == NULL)
	{
		AfxMessageBox(_T("mysql_store_result() failed"));
		mysql_close(conn);
		return;
	}
	else
	{
		AfxMessageBox(_T("mysql_store_result() success"));
	}

	// 输出查询结果
	int num_fields = mysql_num_fields(res);
	while ((row = mysql_fetch_row(res)))
	{
		for (int i = 0; i < num_fields; i++)
		{
			if (row[i] == NULL)
			{
				AfxMessageBox(_T("NULL value detected"));
				continue;
			}

			// 将 UTF-8 编码的字符串转换为宽字符字符串
			int len = MultiByteToWideChar(CP_UTF8, 0, row[i], -1, NULL, 0);
			if (len == 0)
			{
				CString errorMsg;
				errorMsg.Format(_T("MultiByteToWideChar failed with error code: %d"), GetLastError());
				AfxMessageBox(errorMsg);
				continue;
			}

			std::wstring wstr(len, L'\0');
			MultiByteToWideChar(CP_UTF8, 0, row[i], -1, &wstr[0], len);
			CString result(wstr.c_str());
			AfxMessageBox(result);
		}
	}

	// 释放结果集
	mysql_free_result(res);

	// 关闭连接
	mysql_close(conn);
}

报错：

1、找不到mysql.h

解决方案：将mysql的include路径和lib路径设置在项目属性中

D:\DevelopmentTools\Mysql\mysql-5.7.24-winx64\include

D:\DevelopmentTools\Mysql\mysql-5.7.24-winx64\lib

链接器找到libmysql.lib,添加进去即可

2、mysql查找的数据是？乱码

if (mysql_set_character_set(conn, "utf8mb4"))	// 设置连接的字符集为utf8mb4
{
	AfxMessageBox(_T("mysql_set_character_set() failed"));
}
else
{
	AfxMessageBox(_T("mysql is utf8mb4"));
}

同时，对得到的字符还要转换为宽字节

// 将 UTF-8 编码的字符串转换为宽字符字符串
int len = MultiByteToWideChar(CP_UTF8, 0, row[i], -1, NULL, 0);
if (len == 0)
{
	CString errorMsg;
	errorMsg.Format(_T("MultiByteToWideChar failed with error code: %d"), GetLastError());
	AfxMessageBox(errorMsg);
	continue;
}

std::wstring wstr(len, L'\0');
MultiByteToWideChar(CP_UTF8, 0, row[i], -1, &wstr[0], len);
CString result(wstr.c_str());
AfxMessageBox(result);

六、制作关键字字库

新建关键字文件ai.txt，输入若干关键词，每行一个关键词。注意这个关键字文件要求utf-8编码，无BOM头，\n换行，因此最好在Linux下面编辑。用UE等高级编辑器也可以。

使用在线lm工具
http://www.speech.cs.cmu.edu/tools/lmtool-new.html

将keyword.txt上传上去，会生成一堆.dic .lm .vocab等文件。直接下载.tgz的整合文件，解压缩，里面有用的只有.dic和.lm文件。由于lmtool不识别中文，因此.dic文件是空的。需要自己手动添加注音

到官网下载普通话的完整hmm模型 zh_broadcastnews_16k_ptm256_8000.tar.bz2 和完整的字典 zh_broadcastnews_utf8.dic
[https://sourceforge.net/projects/cmusphinx/files/Acoustic%20and%20Language%20Models/Mandarin/](https://sourceforge.net/projects/cmusphinx/files/Acoustic and Language Models/Mandarin/)

参照完整的字典 zh_broadcastnews_utf8.dic，对lmtool生成的.dic文件进行注音，例如

哈密瓜 h a m i g ua

有些名词zh_broadcastnews_utf8.dic里面没有，需要自己一个个字拼起来，例如山竹没有，但是有山和竹的拼音

北山 b ei sh an
成竹 ch eng zh u

则
山竹 sh an zh u

拼音还是比较好办的

报错

1、关键字太长

在 PocketSphinx 中，关键字过长可能导致识别问题，因为默认情况下，PocketSphinx 对每个单词的字符数有一个限制（通常是 34 个字符）。

针对关键字太长的问题，采用划分长句子，应用模糊匹配的方法去寻找mysql中的句子

七、语音识别结果处理

void CAIVoiceAssistantDlg::processRecognitionResult(const std::string& recognizedText)
{
	MYSQL* conn;
	MYSQL_RES* res;
	MYSQL_ROW row;

	const char* server = "localhost";
	const char* user = "root";
	const char* password = "password"; // 请替换为您的 MySQL 密码
	const char* database = "VoiceAssistant";

	conn = mysql_init(NULL);

	if (mysql_real_connect(conn, server, user, password, database, 0, NULL, 0) == NULL)
	{
		AfxMessageBox(_T("mysql_real_connect() failed"));
		mysql_close(conn);
		return;
	}

	if (mysql_set_character_set(conn, "utf8mb4")) // 设置连接的字符集
	{
		AfxMessageBox(_T("mysql_set_character_set() failed"));
	}
	else
	{
		AfxMessageBox(_T("mysql is utf8mb4"));
	}

	// 使用LIKE进行模糊匹配
	std::string query = "SELECT id FROM RecognizeContent WHERE content LIKE '%" + recognizedText + "%'";
	if (mysql_query(conn, query.c_str()))
	{
		AfxMessageBox(_T("SELECT failed"));
		mysql_close(conn);
		return;
	}

	res = mysql_store_result(conn);
	if (res == NULL)
	{
		AfxMessageBox(_T("mysql_store_result() failed"));
		mysql_close(conn);
		return;
	}

	int id = -1;
	if ((row = mysql_fetch_row(res)))
	{
		id = std::stoi(row[0]);
	}

	mysql_free_result(res);

	if (id != -1)
	{
		query = "SELECT content FROM ReplyContent WHERE id = " + std::to_string(id);
		if (mysql_query(conn, query.c_str()))
		{
			AfxMessageBox(_T("SELECT failed"));
			mysql_close(conn);
			return;
		}

		res = mysql_store_result(conn);
		if (res == NULL)
		{
			AfxMessageBox(_T("mysql_store_result() failed"));
			mysql_close(conn);
			return;
		}

		if ((row = mysql_fetch_row(res)))
		{
			// 将UTF-8字符串转换为宽字符字符串
			int len = MultiByteToWideChar(CP_UTF8, 0, row[0], -1, NULL, 0);
			if (len > 0)
			{
				std::wstring wstr(len, L'\0');
				MultiByteToWideChar(CP_UTF8, 0, row[0], -1, &wstr[0], len);
				CString result(wstr.c_str());

				// 调试输出
				//AfxMessageBox(result);

				// 将CString转换为std::string
				CT2CA pszConvertedAnsiString(result);
				std::string replyContent(pszConvertedAnsiString);

				// 调用speak函数
				speak(replyContent);
			}
			else
			{
				AfxMessageBox(_T("Failed to convert reply content to wide string."));
			}
		}

		mysql_free_result(res);
	}
	else
	{
		AfxMessageBox(_T("No matching content found."));
	}

	mysql_close(conn);
}

八、语音播报

// 使用Windows TTS进行语音播报
void CAIVoiceAssistantDlg::speak(const std::string& text)
{
	ISpVoice* pVoice = NULL;

	if (FAILED(::CoInitialize(NULL)))
	{
		AfxMessageBox(_T("Failed to initialize COM library."));
		return;
	}

	HRESULT hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice, (void**)&pVoice);
	if (SUCCEEDED(hr))
	{
		// 使用MultiByteToWideChar将std::string转换为std::wstring
		int len;
		int slength = (int)text.length() + 1;
		len = MultiByteToWideChar(CP_ACP, 0, text.c_str(), slength, 0, 0);
		std::wstring wtext(len, L'\0');
		MultiByteToWideChar(CP_ACP, 0, text.c_str(), slength, &wtext[0], len);

		// 输出调试信息
		AfxMessageBox(CString(wtext.c_str()));

		hr = pVoice->Speak(wtext.c_str(), 0, NULL);
		if (FAILED(hr))
		{
			AfxMessageBox(_T("Speak failed."));
		}
		pVoice->Release();
		pVoice = NULL;
	}
	else
	{
		AfxMessageBox(_T("Failed to create voice instance."));
	}
	::CoUninitialize();
}

总结：

识别率低，无法控制识别的文本

---

// AIVoiceAssistantDlg.h: 头文件
//

#pragma once


// 包含必要的头文件
#include <portaudio.h>       // PortAudio 库头文件，用于音频输入输出
#include <pocketsphinx.h>    // PocketSphinx 库头文件，用于语音识别
#include <sphinxbase/ad.h>   // SphinxBase 库头文件，用于音频录制
#include <sphinxbase/err.h>  // SphinxBase 库头文件，用于错误处理
#include <fstream>           // 文件操作头文件
#include <string>            // 字符串处理头文件
#include <set>               // 集合容器头文件
#include <atlstr.h>          // ATL 字符串类头文件

#include <thread>            // 线程库头文件
#include <vector>            // 向量容器头文件
#include <algorithm>         // 算法头文件
#include <locale>            // 本地化头文件
#include <codecvt>           // 编码转换头文件

#include <iostream>          // 输入输出流头文件

#include <sapi.h>


#define TIMER_ID 999 // 定义定时器 ID

// CAIVoiceAssistantDlg 对话框
class CAIVoiceAssistantDlg : public CDialogEx
{
// 构造
public:
	CAIVoiceAssistantDlg(CWnd* pParent = nullptr);	// 标准构造函数

// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_AIVOICEASSISTANT_DIALOG };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV 支持


// 实现
protected:
	HICON m_hIcon;

	// 生成的消息映射函数
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	afx_msg void OnDestroy();
	DECLARE_MESSAGE_MAP()
public:
	CEdit m_edtText;
	afx_msg void OnBnClickedButtonStart();
	afx_msg void OnBnClickedButtonStop();
	afx_msg void OnTimer(UINT_PTR nIDEvent); // 定时器处理函数

public:
	std::vector<int16> m_audioBuffer;   // 用于存储音频数据
	bool m_bListening = false;			// 语音识别信号
	cmd_ln_t* m_config = nullptr;		// 配置参数指针
	ps_decoder_t* m_ps = nullptr;		// PocketSphinx 解码器指针
	ad_rec_t* m_ad = nullptr;			// 音频录制指针
	uint8 utt_started = FALSE;			// 标志是否开始录制

	PaStream* m_stream = nullptr;		// PortAudio 流指针


	void RecordAudio();
	void ProcessRecordedAudio();
	void ProcessAudioFile(const std::string& filePath);
	CString ExtractTextFromHyp(const char* hyp);


private:
	std::thread m_thread; // 用于音频录制和处理的线程

public:
	void connectToDatabase();
	void processRecognitionResult(const std::string& recognizedText);
	void speak(const std::string& text);
};

// AIVoiceAssistantDlg.cpp: 实现文件
//

#include "pch.h"
#include "framework.h"
#include "AIVoiceAssistant.h"
#include "AIVoiceAssistantDlg.h"
#include "afxdialogex.h"

#include <mysql.h>
#include <iostream>
#include <string>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// PortAudio 参数
#define SAMPLE_RATE 16000
#define FRAMES_PER_BUFFER (2048) // 调整缓冲区大小

static int paCallback(const void* inputBuffer, void* outputBuffer,
	unsigned long framesPerBuffer,
	const PaStreamCallbackTimeInfo* timeInfo,
	PaStreamCallbackFlags statusFlags,
	void* userData)
{
	float* in = (float*)inputBuffer;
	float* monoBuffer = (float*)userData;

	if (inputBuffer == NULL)
	{
		return paContinue;
	}

	for (unsigned long i = 0; i < framesPerBuffer; ++i) {
		monoBuffer[i] = (in[i * 2] + in[i * 2 + 1]) * 0.5f; // 双声道转单声道
	}

	return paContinue;
}

// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_ABOUTBOX };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CAIVoiceAssistantDlg 对话框



CAIVoiceAssistantDlg::CAIVoiceAssistantDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_AIVOICEASSISTANT_DIALOG, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_config = cmd_ln_init(NULL, ps_args(), TRUE,
		"-hmm", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\zh-cn",
		//"-lm", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\zh-cn.lm.bin",
		//"-dict", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\zh-cn.dic",
		"-lm", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\ai3.lm",
		"-dict", "D:\\ASR\\pocketsphinx\\model\\zh-cn\\ai3.dic",
		/*       "-hmm", "D:\\ASR\\pocketsphinx\\model\\en-us\\en-us",
			   "-lm", "D:\\ASR\\pocketsphinx\\model\\en-us\\en-us.lm.bin",
			   "-dict", "D:\\ASR\\pocketsphinx\\model\\en-us\\cmudict-en-us.dict",*/
		NULL);
	if (m_config == NULL)
	{
		AfxMessageBox(_T("1、m_config fail"));
		cmd_ln_free_r(m_config);
	}
	else
	{
		AfxMessageBox(_T("1、m_config success"));
	}

	m_ps = ps_init(m_config);
	if (m_ps == NULL)
	{
		AfxMessageBox(_T("2、m_ps fail"));
	}
	else
	{
		AfxMessageBox(_T("2、m_ps success"));
	}

	if ((m_ad = ad_open_dev("sysdefault", (int)48000)) == NULL)
	{
		AfxMessageBox(_T("3、Failed to open audio device"));
	}
	else
	{
		AfxMessageBox(_T("3、Success to open audio device"));
	}

	//connectToDatabase();
}

void CAIVoiceAssistantDlg::OnDestroy()
{
	// 音频设备
	if (m_ad)
	{
		ad_close(m_ad);
		m_ad = nullptr;
	}

	// 释放解码器
	if (m_ps)
	{
		ps_free(m_ps);
		m_ps = nullptr;
	}

	// 释放配置参数
	if (m_config)
	{
		cmd_ln_free_r(m_config);
		m_config = nullptr;
	}
}

void CAIVoiceAssistantDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT_TEXT, m_edtText);
}

BEGIN_MESSAGE_MAP(CAIVoiceAssistantDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON_START, &CAIVoiceAssistantDlg::OnBnClickedButtonStart)
	ON_BN_CLICKED(IDC_BUTTON_STOP, &CAIVoiceAssistantDlg::OnBnClickedButtonStop)
	ON_WM_DESTROY()
	ON_WM_TIMER()
END_MESSAGE_MAP()


// CAIVoiceAssistantDlg 消息处理程序

BOOL CAIVoiceAssistantDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 将“关于...”菜单项添加到系统菜单中。

	// IDM_ABOUTBOX 必须在系统命令范围内。
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != nullptr)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标

	// TODO: 在此添加额外的初始化代码
	m_bListening = false;

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CAIVoiceAssistantDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CAIVoiceAssistantDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 用于绘制的设备上下文

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 使图标在工作区矩形中居中
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 绘制图标
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CAIVoiceAssistantDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}



void CAIVoiceAssistantDlg::OnBnClickedButtonStart()
{
	// 清空音频缓冲区
	m_audioBuffer.clear();

	// 初始化 PortAudio
	PaError err = Pa_Initialize();
	if (err != paNoError)
	{
		AfxMessageBox(_T("Failed to initialize PortAudio."));
		return;
	}

	// 设置音频流参数
	PaStreamParameters inputParameters;
	inputParameters.device = Pa_GetDefaultInputDevice(); // 获取默认输入设备
	if (inputParameters.device == paNoDevice)
	{
		AfxMessageBox(_T("No default input device."));
		Pa_Terminate();
		return;
	}
	inputParameters.channelCount = 2; // 双声道
	inputParameters.sampleFormat = paInt16; // 16 位整数
	inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency;
	inputParameters.hostApiSpecificStreamInfo = nullptr;

	// 打开音频流
	err = Pa_OpenStream(
		&m_stream,
		&inputParameters,
		nullptr, // 没有输出
		48000, // 采样率
		2048, // 缓冲区大小
		paClipOff, // 禁用剪切
		nullptr, // 没有回调
		nullptr  // 没有用户数据
	);

	// 启动音频流
	if (Pa_StartStream(m_stream) != paNoError)
	{
		AfxMessageBox(_T("Failed to start PortAudio stream."));
		Pa_CloseStream(m_stream);
		Pa_Terminate();
		return;
	}

	// 设置标志以启动录音
	m_bListening = true;

	AfxMessageBox(_T("Recording started. Please speak now..."));

	// 启动录音线程
	std::thread t(&CAIVoiceAssistantDlg::RecordAudio, this);
	t.detach();  // 分离线程

	// 设置定时器，在15秒后停止录音
	SetTimer(TIMER_ID, 15000, NULL);
}

void CAIVoiceAssistantDlg::OnBnClickedButtonStop()
{
	// 停止录音
	m_bListening = false;

	// 停止定时器
	KillTimer(TIMER_ID);

	// 停止 PortAudio 流
	if (m_stream)
	{
		Pa_StopStream(m_stream);
		Pa_CloseStream(m_stream);
		Pa_Terminate();
	}

	// 提示用户停止录音
	AfxMessageBox(_T("Recording stopped. Processing data..."));

	// 处理录音数据
	ProcessRecordedAudio();
}

void CAIVoiceAssistantDlg::RecordAudio()
{
	ps_start_utt(m_ps); // 开始新的语音识别
	int16_t stereoBuffer[2048 * 2];

	while (m_bListening)
	{
		PaError err = Pa_ReadStream(m_stream, stereoBuffer, 2048);
		if (err != paNoError)
		{
			CString errorMsg;
			int len = MultiByteToWideChar(CP_ACP, 0, Pa_GetErrorText(err), -1, NULL, 0);
			if (len > 0)
			{
				WCHAR* wcsErrorText = new WCHAR[len];
				MultiByteToWideChar(CP_ACP, 0, Pa_GetErrorText(err), -1, wcsErrorText, len);
				errorMsg.Format(_T("Failed to read audio: %s"), wcsErrorText);
				delete[] wcsErrorText;
			}
			else
			{
				errorMsg = _T("Failed to read audio: Unknown error");
			}
			AfxMessageBox(errorMsg);
			break;
		}

		// 将双声道数据转换为单声道数据，并添加到缓冲区
		std::vector<int16_t> monoBuffer(2048);
		for (unsigned long i = 0; i < 2048; ++i)
		{
			monoBuffer[i] = (stereoBuffer[i * 2] + stereoBuffer[i * 2 + 1]) / 2; // 简单平均以获得单声道数据
		}

		// 将单声道数据添加到缓冲区
		m_audioBuffer.insert(m_audioBuffer.end(), monoBuffer.begin(), monoBuffer.end());
		ps_process_raw(m_ps, monoBuffer.data(), monoBuffer.size(), FALSE, FALSE);
	}

	ps_end_utt(m_ps); // 结束当前的语音识别

	// 停止音频流
	Pa_StopStream(m_stream);
	Pa_CloseStream(m_stream);
	Pa_Terminate();
}

void CAIVoiceAssistantDlg::ProcessRecordedAudio()
{
	if (m_audioBuffer.empty())
	{
		m_edtText.SetWindowText(_T("No audio data to process."));
		return;
	}

	// 确保 PocketSphinx 正确初始化
	if (!m_ps)
	{
		m_edtText.SetWindowText(_T("PocketSphinx not initialized."));
		return;
	}

	// 开始语音识别
	ps_start_utt(m_ps);

	// 处理音频数据
	ps_process_raw(m_ps, m_audioBuffer.data(), m_audioBuffer.size(), FALSE, FALSE);

	// 结束语音识别
	ps_end_utt(m_ps);

	const char* hyp = ps_get_hyp(m_ps, NULL);
	if (hyp != NULL)
	{
		// 将 UTF-8 编码的字符串转换为宽字符字符串
		int len = MultiByteToWideChar(CP_UTF8, 0, hyp, -1, NULL, 0);
		if (len > 0)
		{
			std::wstring wstr(len, L'\0');
			MultiByteToWideChar(CP_UTF8, 0, hyp, -1, &wstr[0], len);
			CString result(wstr.c_str());

			m_edtText.SetWindowText(result);
			result = "";
			processRecognitionResult(hyp);
			hyp = NULL;
		}
		else
		{
			m_edtText.SetWindowText(_T("Failed to convert recognition result."));
		}
	}
	else
	{
		m_edtText.SetWindowText(_T("No result detected"));
	}
}

void CAIVoiceAssistantDlg::OnTimer(UINT_PTR nIDEvent)
{
	if (nIDEvent == TIMER_ID)
	{
		// 停止录音
		m_bListening = false;

		// 处理录音数据
		ProcessRecordedAudio();

		// 停止定时器
		KillTimer(TIMER_ID);
	}

	CDialogEx::OnTimer(nIDEvent);
}


CString CAIVoiceAssistantDlg::ExtractTextFromHyp(const char* hyp)
{
	return CString(hyp);
}



void CAIVoiceAssistantDlg::ProcessAudioFile(const std::string& filePath)
{
	std::ifstream file(filePath, std::ios::binary);
	if (!file.is_open())
	{
		AfxMessageBox(_T("Failed to open audio file."));
		return;
	}

	// 读取文件内容到缓冲区
	std::vector<int16> audioData((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
	file.close();

	if (audioData.empty())
	{
		AfxMessageBox(_T("No audio data read from file."));
		return;
	}

	// 确保 PocketSphinx 正确初始化
	if (!m_ps)
	{
		AfxMessageBox(_T("PocketSphinx not initialized."));
		return;
	}

	// 开始语音识别
	ps_start_utt(m_ps);

	// 处理音频数据
	ps_process_raw(m_ps, audioData.data(), audioData.size() * sizeof(int16), FALSE, FALSE);

	// 结束语音识别
	ps_end_utt(m_ps);

	const char* hyp = ps_get_hyp(m_ps, NULL);
	if (hyp != NULL)
	{
		CString result = CString(hyp);
		m_edtText.SetWindowText(result);
	}
	else
	{
		m_edtText.SetWindowText(_T("No result detected"));
	}
}

// ------------------------------- 数据库连接 ----------------------------------------------

void CAIVoiceAssistantDlg::processRecognitionResult(const std::string& recognizedText)
{
	MYSQL* conn;
	MYSQL_RES* res;
	MYSQL_ROW row;

	const char* server = "localhost";
	const char* user = "root";
	const char* password = "13525681378.Ll"; // 请替换为您的 MySQL 密码
	const char* database = "VoiceAssistant";

	conn = mysql_init(NULL);

	if (mysql_real_connect(conn, server, user, password, database, 0, NULL, 0) == NULL)
	{
		AfxMessageBox(_T("mysql_real_connect() failed"));
		mysql_close(conn);
		return;
	}

	if (mysql_set_character_set(conn, "utf8mb4")) // 设置连接的字符集
	{
		AfxMessageBox(_T("mysql_set_character_set() failed"));
	}
	else
	{
		AfxMessageBox(_T("mysql is utf8mb4"));
	}

	// 使用LIKE进行模糊匹配
	std::string query = "SELECT id FROM RecognizeContent WHERE content LIKE '%" + recognizedText + "%'";
	if (mysql_query(conn, query.c_str()))
	{
		AfxMessageBox(_T("SELECT failed"));
		mysql_close(conn);
		return;
	}

	res = mysql_store_result(conn);
	if (res == NULL)
	{
		AfxMessageBox(_T("mysql_store_result() failed"));
		mysql_close(conn);
		return;
	}

	int id = -1;
	if ((row = mysql_fetch_row(res)))
	{
		id = std::stoi(row[0]);
	}

	mysql_free_result(res);

	if (id != -1)
	{
		query = "SELECT content FROM ReplyContent WHERE id = " + std::to_string(id);
		if (mysql_query(conn, query.c_str()))
		{
			AfxMessageBox(_T("SELECT failed"));
			mysql_close(conn);
			return;
		}

		res = mysql_store_result(conn);
		if (res == NULL)
		{
			AfxMessageBox(_T("mysql_store_result() failed"));
			mysql_close(conn);
			return;
		}

		if ((row = mysql_fetch_row(res)))
		{
			// 将UTF-8字符串转换为宽字符字符串
			int len = MultiByteToWideChar(CP_UTF8, 0, row[0], -1, NULL, 0);
			if (len > 0)
			{
				std::wstring wstr(len, L'\0');
				MultiByteToWideChar(CP_UTF8, 0, row[0], -1, &wstr[0], len);
				CString result(wstr.c_str());

				// 调试输出
				//AfxMessageBox(result);

				// 将CString转换为std::string
				CT2CA pszConvertedAnsiString(result);
				std::string replyContent(pszConvertedAnsiString);

				// 调用speak函数
				speak(replyContent);
			}
			else
			{
				AfxMessageBox(_T("Failed to convert reply content to wide string."));
			}
		}

		mysql_free_result(res);
	}
	else
	{
		AfxMessageBox(_T("No matching content found."));
	}

	mysql_close(conn);
}

// 使用Windows TTS进行语音播报
void CAIVoiceAssistantDlg::speak(const std::string& text)
{
	ISpVoice* pVoice = NULL;

	if (FAILED(::CoInitialize(NULL)))
	{
		AfxMessageBox(_T("Failed to initialize COM library."));
		return;
	}

	HRESULT hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice, (void**)&pVoice);
	if (SUCCEEDED(hr))
	{
		// 使用MultiByteToWideChar将std::string转换为std::wstring
		int len;
		int slength = (int)text.length() + 1;
		len = MultiByteToWideChar(CP_ACP, 0, text.c_str(), slength, 0, 0);
		std::wstring wtext(len, L'\0');
		MultiByteToWideChar(CP_ACP, 0, text.c_str(), slength, &wtext[0], len);

		// 输出调试信息
		AfxMessageBox(CString(wtext.c_str()));

		hr = pVoice->Speak(wtext.c_str(), 0, NULL);
		if (FAILED(hr))
		{
			AfxMessageBox(_T("Speak failed."));
		}
		pVoice->Release();
		pVoice = NULL;
	}
	else
	{
		AfxMessageBox(_T("Failed to create voice instance."));
	}
	::CoUninitialize();
}

void CAIVoiceAssistantDlg::connectToDatabase()
{
	MYSQL* conn;
	MYSQL_RES* res;
	MYSQL_ROW row;

	const char* server = "localhost";
	const char* user = "root";
	const char* password = "13525681378.Ll"; // 请替换为您的 MySQL 密码
	const char* database = "VoiceAssistant";

	conn = mysql_init(NULL);

	// 连接数据库
	if (mysql_real_connect(conn, server, user, password, database, 0, NULL, 0) == NULL)
	{
		AfxMessageBox(_T("mysql_real_connect() failed"));
		mysql_close(conn);
		return;
	}
	else
	{
		AfxMessageBox(_T("mysql_real_connect() success"));
	}
	if (mysql_set_character_set(conn, "utf8mb4"))	// 设置连接的字符集
	{
		AfxMessageBox(_T("mysql_set_character_set() failed"));
	}
	else
	{
		AfxMessageBox(_T("mysql is utf8mb4"));
	}


	// 执行查询
	if (mysql_query(conn, "SELECT * FROM RecognizeContent"))
	{
		AfxMessageBox(_T("SELECT * FROM RecognizeContent failed"));
		mysql_close(conn);
		return;
	}
	else
	{
		AfxMessageBox(_T("SELECT * FROM RecognizeContent success"));
	}

	res = mysql_store_result(conn);

	if (res == NULL)
	{
		AfxMessageBox(_T("mysql_store_result() failed"));
		mysql_close(conn);
		return;
	}
	else
	{
		AfxMessageBox(_T("mysql_store_result() success"));
	}

	// 输出查询结果
	int num_fields = mysql_num_fields(res);
	while ((row = mysql_fetch_row(res)))
	{
		for (int i = 0; i < num_fields; i++)
		{
			if (row[i] == NULL)
			{
				AfxMessageBox(_T("NULL value detected"));
				continue;
			}

			// 将 UTF-8 编码的字符串转换为宽字符字符串
			int len = MultiByteToWideChar(CP_UTF8, 0, row[i], -1, NULL, 0);
			if (len == 0)
			{
				CString errorMsg;
				errorMsg.Format(_T("MultiByteToWideChar failed with error code: %d"), GetLastError());
				AfxMessageBox(errorMsg);
				continue;
			}

			std::wstring wstr(len, L'\0');
			MultiByteToWideChar(CP_UTF8, 0, row[i], -1, &wstr[0], len);
			CString result(wstr.c_str());
			AfxMessageBox(result);
		}
	}

	// 释放结果集
	mysql_free_result(res);

	// 关闭连接
	mysql_close(conn);
}