devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

讯飞离线语音命令词+TTS离线发音，实现命令词交互（windows dll for unity插件）_asr_offline_record_sample

作者：你好赵伟 | 2024-02-21 13:33:18

赞

踩

asr_offline_record_sample

步骤一

登录讯飞平台注册并创建自己的应用

https://www.xfyun.cn 

 

步骤二

下载离线命令词识别SDK windows MSC ，注意下载的SDK会根据你的appid捆绑在代码段里，应该是讯飞的版权策略

步骤三

下载离线语音合成（普通版）SDK ，

 

步骤四

根据官方提示需要使用 vs2010 版本 不想折腾版本兼容问题，就乖乖安装。

链接：网盘下载地址    提取码：9541 

步骤五

1.解压  离线命令词识别SDK压缩包 和 离线语音合成（普通版）压缩包。

2.使用vs2010打开项目/解决方案  打开解压后samples文件夹里的工程文件。

3.配置换开发环境 ，请参考  离线命令词识别 Windows SDK 文档 和 离线语音合成 Windows SDK 文档

4.确定samples工程可以正常运行。

步骤六 

将离线语音合成打包成DLL库

1.当前运行的工程为win32控制台模式，修改成dll ，右键项目解决方案 -> 属性 ->常规->配置类型修改成（动态库.dll）

2.替换下面改造dll代码，tts_offline_sample.c，注意替换成自己的appid

  1. /*
  2. * 语音合成（Text To Speech，TTS）技术能够自动将任意文字实时转换为连续的
  3. * 自然语音，是一种能够在任何时间、任何地点，向任何人提供语音信息服务的
  4. * 高效便捷手段，非常符合信息时代海量数据、动态更新和个性化查询的需求。
  5. */
  6.  
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <errno.h>
  11. #include <intrin.h>
  12.  
  13. #include <string.h>
  14. #include <Windows.h>
  15. #include <locale.h>
  16.  
  17.  
  18. #include "qtts.h"
  19. #include "msp_cmn.h"
  20. #include "msp_errors.h"
  21.  
  22. #ifdef _WIN64
  23. #pragma comment(lib,"../../libs/msc_x64.lib")//x64
  24. #else
  25. #pragma comment(lib,"../../libs/msc.lib")//x86
  26. #endif
  27.  
  28. /* wav音频头部格式 */
  29. typedef struct _wave_pcm_hdr
  30. {
  31.     char            riff[4];                // = "RIFF"
  32.     int                size_8;                 // = FileSize - 8
  33.     char            wave[4];                // = "WAVE"
  34.     char            fmt[4];                 // = "fmt "
  35.     int                fmt_size;                // = 下一个结构体的大小 : 16
  36.  
  37.     short int       format_tag;             // = PCM : 1
  38.     short int       channels;               // = 通道数 : 1
  39.     int                samples_per_sec;        // = 采样率 : 8000 | 6000 | 11025 | 16000
  40.     int                avg_bytes_per_sec;      // = 每秒字节数 : samples_per_sec * bits_per_sample / 8
  41.     short int       block_align;            // = 每采样点字节数 : wBitsPerSample / 8
  42.     short int       bits_per_sample;        // = 量化比特数: 8 | 16
  43.  
  44.     char            data[4];                // = "data";
  45.     int                data_size;              // = 纯数据长度 : FileSize - 44 
  46. } wave_pcm_hdr;
  47.  
  48. /* 默认wav音频头部数据 */
  49. wave_pcm_hdr default_wav_hdr = 
  50. {
  51.     { 'R', 'I', 'F', 'F' },
  52.     0,
  53.     {'W', 'A', 'V', 'E'},
  54.     {'f', 'm', 't', ' '},
  55.     16,
  56.     1,
  57.     1,
  58.     16000,
  59.     32000,
  60.     2,
  61.     16,
  62.     {'d', 'a', 't', 'a'},
  63.     0  
  64. };
  65.  
  66.  
  67. char *wchar_t_to_char(const wchar_t *str){
  68.     char *result = NULL;
  69.     int textlen = 0;
  70.     textlen = WideCharToMultiByte(CP_ACP,0,str,-1,NULL,0,NULL,NULL);
  71.     result = (char*)malloc((textlen+1)*sizeof(char));
  72.     memset(result,0,sizeof(char)*(textlen+1));
  73.     WideCharToMultiByte(CP_ACP,0,str,-1,result,textlen,NULL,NULL);
  74.     return result;
  75. }
  76.  
  77. /* 文本合成 */
  78. int text_to_speech(const char* src_text, const char* des_path, const char* params)
  79. {
  80.     int          ret          = -1;
  81.     FILE*        fp           = NULL;
  82.     const char*  sessionID    = NULL;
  83.     unsigned int audio_len    = 0;
  84.     wave_pcm_hdr wav_hdr      = default_wav_hdr;
  85.     int          synth_status = MSP_TTS_FLAG_STILL_HAVE_DATA;
  86.  
  87.     if (NULL == src_text || NULL == des_path)
  88.     {
  89.         printf("params is error!\n");
  90.         return 0;
  91.     }
  92.     fp = fopen(des_path, "wb");
  93.     if (NULL == fp)
  94.     {
  95.         printf("open %s error.\n", des_path);
  96.         return 1;
  97.     }
  98.     /* 开始合成 */
  99.     sessionID = QTTSSessionBegin(params, &ret);
  100.     if (MSP_SUCCESS != ret)
  101.     {
  102.         printf("QTTSSessionBegin failed, error code: %d.\n", ret);
  103.         fclose(fp);
  104.         return 2;
  105.     }
  106.     ret = QTTSTextPut(sessionID, src_text, (unsigned int)strlen(src_text), NULL);
  107.     if (MSP_SUCCESS != ret)
  108.     {
  109.         printf("QTTSTextPut failed, error code: %d.\n",ret);
  110.         QTTSSessionEnd(sessionID, "TextPutError");
  111.         fclose(fp);
  112.         return 3;
  113.     }
  114.     printf("正在合成 ...\n");
  115.     fwrite(&wav_hdr, sizeof(wav_hdr) ,1, fp); //添加wav音频头，使用采样率为16000
  116.     while (1) 
  117.     {
  118.         /* 获取合成音频 */
  119.         const void* data = QTTSAudioGet(sessionID, &audio_len, &synth_status, &ret);
  120.         if (MSP_SUCCESS != ret)
  121.             break;
  122.         if (NULL != data)
  123.         {
  124.             fwrite(data, audio_len, 1, fp);
  125.             wav_hdr.data_size += audio_len; //计算data_size大小
  126.         }
  127.         if (MSP_TTS_FLAG_DATA_END == synth_status)
  128.             break;
  129.     }
  130.     printf("\n");
  131.     if (MSP_SUCCESS != ret)
  132.     {
  133.         printf("QTTSAudioGet failed, error code: %d.\n",ret);
  134.         QTTSSessionEnd(sessionID, "AudioGetError");
  135.         fclose(fp);
  136.         return 4;
  137.     }
  138.     /* 修正wav文件头数据的大小 */
  139.     wav_hdr.size_8 += wav_hdr.data_size + (sizeof(wav_hdr) - 8);
  140.  
  141.     /* 将修正过的数据写回文件头部,音频文件为wav格式 */
  142.     fseek(fp, 4, 0);
  143.     fwrite(&wav_hdr.size_8,sizeof(wav_hdr.size_8), 1, fp); //写入size_8的值
  144.     fseek(fp, 40, 0); //将文件指针偏移到存储data_size值的位置
  145.     fwrite(&wav_hdr.data_size,sizeof(wav_hdr.data_size), 1, fp); //写入data_size的值
  146.     fclose(fp);
  147.     fp = NULL;
  148.     /* 合成完毕 */
  149.     ret = QTTSSessionEnd(sessionID, "Normal");
  150.     if (MSP_SUCCESS != ret)
  151.     {
  152.         printf("QTTSSessionEnd failed, error code: %d.\n",ret);
  153.     }
  154.  
  155.     return 5;
  156. }
  157.  
  158. /* 用户登录 */
  159. __declspec(dllexport)  int loading_tts(){
  160.     int         ret                  = MSP_SUCCESS;
  161.     const char* login_params         = "appid = 替换自己的appid, work_dir = .";//登录参数,appid与msc库绑定,请勿随意改动
  162.     ret = MSPLogin(NULL, NULL, login_params); //第一个参数是用户名，第二个参数是密码，第三个参数是登录参数，用户名和密码可在http://www.xfyun.cn注册获取
  163.     if (MSP_SUCCESS != ret)
  164.     {
  165.         MSPLogout(); 
  166.         return 0;
  167.     }
  168.     return 1;
  169. }
  170.  
  171. /* 开始转换 */
  172. __declspec(dllexport)  int to_speech(wchar_t * wav_path, wchar_t * tts_text){
  173.     int         ret                  = MSP_SUCCESS;
  174.     const char* session_begin_params = "engine_type = local, voice_name = xiaoyan, text_encoding = GB2312, tts_res_path = fo|C:\\xunfei_speech\\xiaoyan.jet;fo|C:\\xunfei_speech\\common.jet, sample_rate = 16000, speed = 50, volume = 50, pitch = 50, rdn = 2";
  175.     //const char* filename             = "C:\\xunfei_speech\\tts_sample.wav"; //合成的语音文件名称s
  176.     //const char* text                 = "亲爱的用户，您好，这是一个语音合成示例，感谢您对小螺丝语音技术的支持！小螺丝是亚太地区最大的上市公司，股票代码：002233"; //合成文本
  177.     const char* filename             =wchar_t_to_char(wav_path);
  178.     const char* text                 =wchar_t_to_char(tts_text);
  179.     ret = text_to_speech(text, filename, session_begin_params);
  180.     return ret;
  181. }
  182.  
  183.  
  184. /* 释放 */
  185. __declspec(dllexport)  int free_tts(){
  186.    MSPLogout(); 
  187.    return 1;
  188. }

3.重新生成DLL

 

步骤七

将离线语音命令词打包成DLL库

1.当前运行的工程为win32控制台模式，修改成dll ，右键项目解决方案 -> 属性 ->常规->配置类型修改成（动态库.dll）

2.替换下面改造dll代码，asr_record_sample.c，注意替换成自己的appid

  1. /*
  2. * 语音听写(iFly Auto Transform)技术能够实时地将语音转换成对应的文字。
  3. */
  4.  
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. //#include <string.h>
  8.  
  9. #include <windows.h>
  10. #include <conio.h>
  11. #include <errno.h>
  12. #include <process.h>
  13.  
  14.  
  15. #include "../../include/qisr.h"
  16. #include "../../include/msp_cmn.h"
  17. #include "../../include/msp_errors.h"
  18. #include "./include/speech_recognizer.h"
  19.  
  20. #define FRAME_LEN	640 
  21. #define	BUFFER_SIZE	4096
  22.  
  23. enum{
  24. 	EVT_START = 0,
  25. 	EVT_STOP,
  26. 	EVT_QUIT,
  27. 	EVT_TOTAL
  28. };
  29. static HANDLE events[EVT_TOTAL] = {NULL,NULL,NULL};
  30.  
  31. static COORD begin_pos = {0, 0};
  32. static COORD last_pos = {0, 0};
  33. #define SAMPLE_RATE_16K     (16000)
  34. #define SAMPLE_RATE_8K      (8000)
  35. #define MAX_GRAMMARID_LEN   (32)
  36. #define MAX_PARAMS_LEN      (1024)
  37.  
  38. const char * ASR_RES_PATH        = "fo|C:\\xunfei_speech\\command_speech\\common.jet";  //离线语法识别资源路径
  39. #ifdef _WIN64
  40. const char * GRM_BUILD_PATH      = "C:\\xunfei_speech\\command_speech\\GrmBuilld_x64";  //构建离线语法识别网络生成数据保存路径
  41. #else
  42. const char * GRM_BUILD_PATH      = "C:\\xunfei_speech\\command_speech\\GrmBuilld";  //构建离线语法识别网络生成数据保存路径
  43. #endif
  44. const char * GRM_FILE            = "C:\\xunfei_speech\\command_speech\\call.bnf"; //构建离线识别语法网络所用的语法文件
  45. const char * LEX_NAME            = "contact"; //更新离线识别语法的contact槽（语法文件为此示例中使用的call.bnf）
  46. typedef struct _UserData {
  47. 	int     build_fini;  //标识语法构建是否完成
  48. 	int     update_fini; //标识更新词典是否完成
  49. 	int     errcode; //记录语法构建或更新词典回调错误码
  50. 	char    grammar_id[MAX_GRAMMARID_LEN]; //保存语法构建返回的语法ID
  51. }UserData;
  52.  
  53. const char *get_audio_file(void); //选择进行离线语法识别的语音文件
  54. int build_grammar(UserData *udata); //构建离线识别语法网络
  55. int update_lexicon(UserData *udata); //更新离线识别语法词典
  56. int run_asr(UserData *udata); //进行离线语法识别
  57.  
  58. int build_grm_cb(int ecode, const char *info, void *udata)
  59. {
  60. 	UserData *grm_data = (UserData *)udata;
  61.  
  62. 	if (NULL != grm_data) {
  63. 		grm_data->build_fini = 1;
  64. 		grm_data->errcode = ecode;
  65. 	}
  66.  
  67. 	if (MSP_SUCCESS == ecode && NULL != info) {
  68. 		printf("构建语法成功！ 语法ID:%s\n", info);
  69. 		if (NULL != grm_data)
  70. 			_snprintf(grm_data->grammar_id, MAX_GRAMMARID_LEN - 1, info);
  71. 	}
  72. 	else
  73. 		printf("构建语法失败！%d\n", ecode);
  74.  
  75. 	return 0;
  76. }
  77.  
  78. int build_grammar(UserData *udata)
  79. {
  80. 	FILE *grm_file                           = NULL;
  81. 	char *grm_content                        = NULL;
  82. 	unsigned int grm_cnt_len                 = 0;
  83. 	char grm_build_params[MAX_PARAMS_LEN]    = {NULL};
  84. 	int ret                                  = 0;
  85.  
  86. 	grm_file = fopen(GRM_FILE, "rb");	
  87. 	if(NULL == grm_file) {
  88. 		printf("打开\"%s\"文件失败！[%s]\n", GRM_FILE, strerror(errno));
  89. 		return -1; 
  90. 	}
  91.  
  92. 	fseek(grm_file, 0, SEEK_END);
  93. 	grm_cnt_len = ftell(grm_file);
  94. 	fseek(grm_file, 0, SEEK_SET);
  95.  
  96. 	grm_content = (char *)malloc(grm_cnt_len + 1);
  97. 	if (NULL == grm_content)
  98. 	{
  99. 		printf("内存分配失败!\n");
  100. 		fclose(grm_file);
  101. 		grm_file = NULL;
  102. 		return -1;
  103. 	}
  104. 	fread((void*)grm_content, 1, grm_cnt_len, grm_file);
  105. 	grm_content[grm_cnt_len] = '\0';
  106. 	fclose(grm_file);
  107. 	grm_file = NULL;
  108.  
  109. 	_snprintf(grm_build_params, MAX_PARAMS_LEN - 1, 
  110. 		"engine_type = local, \
  111. 		asr_res_path = %s, sample_rate = %d, \
  112. 		grm_build_path = %s, ",
  113. 		ASR_RES_PATH,
  114. 		SAMPLE_RATE_16K,
  115. 		GRM_BUILD_PATH
  116. 		);
  117. 	ret = QISRBuildGrammar("bnf", grm_content, grm_cnt_len, grm_build_params, build_grm_cb, udata);
  118.  
  119. 	free(grm_content);
  120. 	grm_content = NULL;
  121.  
  122. 	return ret;
  123. }
  124.  
  125. int update_lex_cb(int ecode, const char *info, void *udata)
  126. {
  127. 	UserData *lex_data = (UserData *)udata;
  128.  
  129. 	if (NULL != lex_data) {
  130. 		lex_data->update_fini = 1;
  131. 		lex_data->errcode = ecode;
  132. 	}
  133.  
  134. 	if (MSP_SUCCESS == ecode)
  135. 		printf("更新词典成功！\n");
  136. 	else
  137. 		printf("更新词典失败！%d\n", ecode);
  138.  
  139. 	return 0;
  140. }
  141.  
  142. int update_lexicon(UserData *udata)
  143. {
  144. 	const char *lex_content                   = "丁伟\n黄辣椒";
  145. 	unsigned int lex_cnt_len                  = strlen(lex_content);
  146. 	char update_lex_params[MAX_PARAMS_LEN]    = {NULL}; 
  147.  
  148. 	_snprintf(update_lex_params, MAX_PARAMS_LEN - 1, 
  149. 		"engine_type = local, text_encoding = GB2312, \
  150. 		asr_res_path = %s, sample_rate = %d, \
  151. 		grm_build_path = %s, grammar_list = %s, ",
  152. 		ASR_RES_PATH,
  153. 		SAMPLE_RATE_16K,
  154. 		GRM_BUILD_PATH,
  155. 		udata->grammar_id);
  156. 	return QISRUpdateLexicon(LEX_NAME, lex_content, lex_cnt_len, update_lex_params, update_lex_cb, udata);
  157. }
  158.  
  159.  
  160. static void show_result(char *string, char is_over)
  161. {
  162. 	COORD orig, current;
  163. 	CONSOLE_SCREEN_BUFFER_INFO info;
  164. 	HANDLE w = GetStdHandle(STD_OUTPUT_HANDLE);
  165. 	GetConsoleScreenBufferInfo(w, &info);
  166. 	current = info.dwCursorPosition;
  167.  
  168. 	if(current.X == last_pos.X && current.Y == last_pos.Y ) {
  169. 		SetConsoleCursorPosition(w, begin_pos);
  170. 	} else {
  171. 		/* changed by other routines, use the new pos as start */
  172. 		begin_pos = current;
  173. 	}
  174. 	if(is_over)
  175. 		SetConsoleTextAttribute(w, FOREGROUND_GREEN);
  176. 	printf("Result: [ %s ]\n", string);
  177. 	if(is_over)
  178. 		SetConsoleTextAttribute(w, info.wAttributes);
  179.  
  180. 	GetConsoleScreenBufferInfo(w, &info);
  181. 	last_pos = info.dwCursorPosition;
  182. }
  183.  
  184. static char *g_result = NULL;  //
  185.  
  186. static char bk_result[1024]="0";
  187.  
  188.  
  189. static unsigned int g_buffersize = BUFFER_SIZE;
  190. static UserData g_asr_data; 
  191. struct speech_rec g_asr;
  192.  
  193. void on_result(const char *result, char is_last)
  194. {
  195. 	if (result) {
  196. 		size_t left = g_buffersize - 1 - strlen(g_result);
  197. 		size_t size = strlen(result);
  198. 		if (left < size) {
  199. 			g_result = (char*)realloc(g_result, g_buffersize + BUFFER_SIZE);
  200. 			if (g_result)
  201. 				g_buffersize += BUFFER_SIZE;
  202. 			else {
  203. 				printf("mem alloc failed\n");
  204. 				return;
  205. 			}
  206. 		}
  207.  
  208. 		strncat(g_result, result, size);
  209.         printf(g_result);
  210. 		strcpy(bk_result,g_result);
  211.  
  212. 		//show_result(g_result, is_last);
  213. 	}
  214. }
  215. void on_speech_begin()
  216. {
  217. 	if (g_result)
  218. 	{
  219. 		free(g_result);
  220. 	}
  221.  
  222.  
  223. 	g_result = (char*)malloc(BUFFER_SIZE);
  224. 	g_buffersize = BUFFER_SIZE;
  225. 	memset(g_result, 0, g_buffersize);
  226. 	printf("Start Listening...\n");
  227.  
  228.  
  229. }
  230. void on_speech_end(int reason)
  231. {
  232. 	if (reason == END_REASON_VAD_DETECT){
  233. 		printf("\nSpeaking done \n");
  234.        // g_result = (char*)"Speaking done";
  235. 		//strcpy(bk_result,"Speaking done");
  236. 	}else{
  237. 		printf("\nRecognizer error %d\n", reason);
  238. 		//g_result = (char*)"Recognizer error";
  239. 		//strcpy(bk_result,"Recognizer error");
  240. 	}
  241. }
  242.  
  243. /* demo recognize the audio from microphone */
  244. static void recognize_mic(const char* session_begin_params)
  245. {
  246. 	int errcode;
  247. 	int i = 0;
  248. 	HANDLE helper_thread = NULL;
  249.  
  250. 	DWORD waitres;
  251. 	char isquit = 0;
  252.  
  253. 	struct speech_rec_notifier recnotifier = {
  254. 		on_result,
  255. 		on_speech_begin,
  256. 		on_speech_end
  257. 	};
  258.  
  259. 	errcode = sr_init(&g_asr, session_begin_params, SR_MIC, DEFAULT_INPUT_DEVID, &recnotifier);
  260. 	if (errcode) {
  261. 		printf("speech recognizer init failed\n");
  262. 		return;
  263. 	}
  264. }
  265.  
  266.  
  267. int run_asr(UserData *udata)
  268. {
  269. 	char asr_params[MAX_PARAMS_LEN]    = {NULL};
  270. 	const char *rec_rslt               = NULL;
  271. 	const char *session_id             = NULL;
  272. 	const char *asr_audiof             = NULL;
  273. 	FILE *f_pcm                        = NULL;
  274. 	char *pcm_data                     = NULL;
  275. 	long pcm_count                     = 0;
  276. 	long pcm_size                      = 0;
  277. 	int last_audio                     = 0;
  278. 	int aud_stat                       = MSP_AUDIO_SAMPLE_CONTINUE;
  279. 	int ep_status                      = MSP_EP_LOOKING_FOR_SPEECH;
  280. 	int rec_status                     = MSP_REC_STATUS_INCOMPLETE;
  281. 	int rss_status                     = MSP_REC_STATUS_INCOMPLETE;
  282. 	int errcode                        = -1;
  283. 	int aud_src                        = 1;
  284.  
  285. 	//离线语法识别参数设置
  286. 	_snprintf(asr_params, MAX_PARAMS_LEN - 1, 
  287. 		"engine_type = local, \
  288. 		asr_res_path = %s, sample_rate = %d, \
  289. 		grm_build_path = %s, local_grammar = %s, \
  290. 		result_type = xml, result_encoding = GB2312, ",
  291. 		ASR_RES_PATH,
  292. 		SAMPLE_RATE_16K,
  293. 		GRM_BUILD_PATH,
  294. 		udata->grammar_id
  295. 		);
  296.  
  297. 		recognize_mic(asr_params);
  298.  
  299. 	return 0;
  300. }
  301.  
  302.  
  303. int main(int argc, char* argv[]){
  304.  	const char *login_config    = "appid = 5fa0d519"; //登录参数
  305. 	int ret                    = 0 ;
  306. 	ret = MSPLogin(NULL, NULL, login_config); //第一个参数为用户名，第二个参数为密码，传NULL即可，第三个参数是登录参数
  307. 	if (MSP_SUCCESS != ret) {
  308. 		printf("登录失败：%d\n", ret);
  309. 		//goto exit;
  310. 	}
  311.  
  312. 	memset(&g_asr_data, 0, sizeof(UserData));
  313. 	printf("构建离线识别语法网络...\n");
  314. 	ret = build_grammar(&g_asr_data);  //第一次使用某语法进行识别，需要先构建语法网络，获取语法ID，之后使用此语法进行识别，无需再次构建
  315. 	if (MSP_SUCCESS != ret) {
  316. 		printf("构建语法调用失败！\n");
  317. 	}
  318.  
  319. 	while (1 != g_asr_data.build_fini)
  320. 		_sleep(300);
  321. 	if (MSP_SUCCESS != g_asr_data.errcode)
  322. 	printf("离线识别语法网络构建完成，开始识别...\n");	
  323.  
  324. 	ret = run_asr(&g_asr_data);
  325. 	if (MSP_SUCCESS != ret) {
  326. 		printf("离线语法识别出错: %d \n", ret);
  327. 	}
  328. 	while(1){
  329. 	sr_start_listening(&g_asr);
  330.     _sleep(1000);
  331. 	}
  332. 	return 1;
  333. }
  334.  
  335. //初始化登录
  336. __declspec(dllexport)  int loading_msp(){
  337. 	const char *login_config    = "appid = 替换自己的appid"; //登录参数
  338. 	int ret                    = 0 ;
  339. 	ret = MSPLogin(NULL, NULL, login_config); //第一个参数为用户名，第二个参数为密码，传NULL即可，第三个参数是登录参数
  340. 	if (MSP_SUCCESS != ret) {
  341. 		MSPLogout();
  342. 		return 0;
  343. 	}
  344. 	memset(&g_asr_data, 0, sizeof(UserData));
  345.     return 1;
  346. }
  347.  
  348. /* 构建命令词网络 */
  349. __declspec(dllexport)  int build_net_msp(){
  350. 	int ret                    = 0 ;
  351. 	printf("构建离线识别语法网络...\n");
  352. 	ret = build_grammar(&g_asr_data);  //第一次使用某语法进行识别，需要先构建语法网络，获取语法ID，之后使用此语法进行识别，无需再次构建
  353. 	if (MSP_SUCCESS != ret) {
  354. 		printf("构建语法调用失败！\n");
  355. 		return -1;
  356. 	}
  357. 	while (1 != g_asr_data.build_fini)
  358. 		_sleep(300);
  359. 	if (MSP_SUCCESS != g_asr_data.errcode)
  360. 		return 0;
  361. 	return 1;
  362. }
  363.  
  364. /* 更新词典槽 */
  365. __declspec(dllexport)  int update_lexicon_msp(){
  366. 	int ret                    = 0 ;
  367. 	printf("更新离线语法词典...\n");
  368. 	ret = update_lexicon(&g_asr_data);  //当语法词典槽中的词条需要更新时，调用QISRUpdateLexicon接口完成更新
  369. 	if (MSP_SUCCESS != ret) {
  370. 		printf("更新词典调用失败！\n");
  371. 		return 0;
  372. 	}
  373. 	while (1 != g_asr_data.update_fini)
  374. 		_sleep(300);
  375. 	if (MSP_SUCCESS != g_asr_data.errcode)
  376. 		return 0;
  377. 	return 1;
  378. }
  379.  
  380. /* 识别命令词 */
  381. __declspec(dllexport)  int init_run_msp(){
  382. 	int ret                    = 0 ;
  383. 	ret = run_asr(&g_asr_data);
  384. 	if (MSP_SUCCESS != ret) {
  385. 		printf("离线语法识别出错: %d \n", ret);
  386. 		return 0;
  387. 	}
  388. 	return 1;
  389. }
  390.  
  391. static wchar_t * char2wchar(char *str){ 
  392. 	int length = strlen(str)+1;
  393. 	wchar_t *t = (wchar_t*)malloc(sizeof(wchar_t)*length);
  394. 	memset(t,0,length*sizeof(wchar_t));
  395. 	MultiByteToWideChar(CP_ACP,0,str,strlen(str),t,length);
  396. 	return t;
  397. }
  398.  
  399. /* 识别命令词 */
  400. __declspec(dllexport) wchar_t* start_listening(){
  401.     
  402.     wchar_t* re;
  403. 	if (sr_start_listening(&g_asr)!=NULL){
  404.     // char * str1 = "小螺丝科技有限公司hahah1523";//g_result
  405. 	}
  406. 	re = char2wchar(bk_result);	
  407. 	strcpy(bk_result,"0");
  408. 	return re;
  409. }
  410.  
  411.  
  412. /* 释放 */
  413. __declspec(dllexport)  int free_msp(){
  414. 	MSPLogout();
  415. 	return 1;
  416. }

3.编译，重新生成DLL

4.提示 ：打包dll后，确保在dll在unity里能够正常读取讯飞语音包引擎文件，这里添加了绝对路径 ，创建文件夹  c:\xunfei_speech 将SDK里的资源文件复制进去确保能够真确引用。

步骤八  Unity 调用 dll 实现业务交互调用

1.创建unity工程 speech_demo

2.Unity项目目录 Assets/Scenes 目录下创建目录 全路径为 Assets/Scenes/Plugins/Windows/X86_64（64位平台） Assets/Scenes/Plugins/Windows/X86（32位平台）创建Unity可引用的dll目录，将 asr_record_sample.dll、tts_offline_sample.dll，msc_x64.dll(两个引擎可共用一个)，x86平台为msc_x.dll，复制到目录下。

3.创建脚本ToSpeech.cs，脚本代码如下：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. using System;
  6. using System.Text;
  7. using System.Linq;
  8. using System.IO;
  9. using System.Xml;
  10.  
  11. using System.Runtime.InteropServices;
  12.  
  13.  
  14.  
  15. public class ToSpeech : MonoBehaviour
  16. {
  17.  
  18.      //初始化TTS离线朗读语音引擎
  19.     [DllImport("tts_offline_sample", EntryPoint = "loading_tts", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  20.     extern static int loading_tts();
  21.     //合成语音文件
  22.     [DllImport("tts_offline_sample", EntryPoint = "to_speech", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  23.     extern static int to_speech([MarshalAs(UnmanagedType.LPWStr)]string wav_path, [MarshalAs(UnmanagedType.LPWStr)]string tts_text);
  24.     //释放TTS朗读语音引擎
  25.     [DllImport("tts_offline_sample", EntryPoint = "free_tts", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  26.     extern static int free_tts();
  27.  
  28.     //初始化命令词识别离线引擎
  29.     [DllImport("asr_offline_record_sample", EntryPoint = "loading_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  30.     public static extern int loading_msp();
  31.     //初始化预热识别
  32.     [DllImport("asr_offline_record_sample", EntryPoint = "init_run_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  33.     static extern int init_run_msp();   
  34.     //构建识别网络
  35.     [DllImport("asr_offline_record_sample", EntryPoint = "build_net_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  36.     static extern int build_net_msp();
  37.     //更新词典槽
  38.     [DllImport("asr_offline_record_sample", EntryPoint = "update_lexicon_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  39.     static extern int update_lexicon_msp();
  40.      //开启监听——micphone
  41.     [DllImport("asr_offline_record_sample", EntryPoint = "start_listening", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  42.     static extern IntPtr start_listening();   
  43.     //释放命令词识别离线引擎
  44.     [DllImport("asr_offline_record_sample", EntryPoint = "free_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  45.     static extern int free_msp();
  46.  
  47.     //test
  48.     //[DllImport("asr_offline_record_sample", EntryPoint = "test", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
  49.     //public static extern int test();
  50.  
  51.     public bool listening_off = false; //监听器循环开启关闭开关
  52.     public int confidenct = 25; //置信度调节
  53.     private int tts_off = 0;
  54.     private float lastTime;
  55.     private float curTime;
  56.  
  57.  
  58.  
  59.     void Start()
  60.     {
  61.        init_listing();
  62.     }
  63.  
  64.     void Update()
  65.     {
  66.       update_listing();
  67.     }
  68.  
  69.  
  70.  
  71. //讲述人///
  72.  
  73.     public AudioSource aud;//需要节点关联
  74.  
  75.     IEnumerator LoadAudio(string recordPath)
  76.     {
  77.         WWW www = new WWW(recordPath);
  78.         yield return www;
  79.         var clipTemp = www.GetAudioClip();
  80.         aud.clip = clipTemp;
  81.         aud.Play();
  82.     }
  83.  
  84.     private void speech_tts(string tts_text)
  85.     {
  86.  
  87.         string wav_path = @"C:\\xunfei_speech\\" + tts_text + ".wav";
  88.         if (File.Exists(wav_path))
  89.         {
  90.             StartCoroutine(LoadAudio(wav_path));
  91.             return;
  92.         }
  93.         //如果文件已经生成就不用在合成了，直接读取播放
  94.  
  95.         tts_off = loading_tts();
  96.         if (tts_off == 1)
  97.         {
  98.             print("初始化朗读成功：" + tts_off);
  99.             int ret2 = to_speech(wav_path, tts_text);
  100.             StartCoroutine(LoadAudio(wav_path));
  101.         }
  102.         else
  103.         {
  104.             print("初始化失败：" + tts_off);
  105.         }
  106.         free_tts();
  107.     }
  108.  
  109.  
  110. /聆听人//
  111.  
  112.     //功能：初始化监听器
  113.     void init_listing()
  114.     {
  115.         if (1 == loading_msp())
  116.         {
  117.             print("载入初始化成功");
  118.             //实际应用中只执行一次///
  119.             if (1 == build_net_msp())
  120.             {
  121.                 print("下载构建网络命令词成功");
  122.                 if (1 == update_lexicon_msp())
  123.                 {
  124.                    print("更新词典槽成功");
  125.                 }
  126.             }
  127.             
  128.             if (1 == init_run_msp())
  129.             {
  130.                 print("预热命令词成功");
  131.                 listening_off = true;
  132.             }
  133.         }
  134.         lastTime = Time.time;
  135.     }
  136.  
  137.     //功能：循环发送mic监听器开启，可以重复发送，sdk 做了同步处理
  138.     //返回：xml格式数据
  139.     string update_listing()
  140.     {
  141.         string restr = "0";
  142.         curTime = Time.time;
  143.         if (curTime - lastTime >= 1)
  144.         {
  145.             if (listening_off)
  146.             {
  147.                 IntPtr ip = start_listening();
  148.                 restr = Marshal.PtrToStringUni(ip);
  149.                 print("打开麦克风监听中..." + restr);
  150.                 get_result_confidenct(restr);//解析xml
  151.             }
  152.            // print(curTime - lastTime);
  153.             lastTime = curTime;
  154.         }
  155.         return restr;
  156.     }
  157.  
  158.     //功能：释放监听器
  159.     void OnDestroy(){
  160.         free_msp();
  161.         print("退出了");
  162.     } 
  163.  
  164.     //功能：语音识别结果返回xml解析
  165.     //传入：xml字符串；
  166.     //返回：置信度结果，是一个0~1的浮点类型数字；
  167.     double get_result_confidenct(string strxml)
  168.     {
  169.         // string strxml = @"<?xml version='1.0' encoding='gb2312' standalone='yes' ?><nlp>  <version>1.1</version>  <rawtext>您好</rawtext>  <confidence>27</confidence>  <engine>local</engine>  <result>    <focus>您好</focus>    <confidence>18</confidence>    <object>      <您好 id='65535'>您好</您好>    </object>  </result></nlp>";
  170.         if (Equals(strxml,"0")) { return 0; }  //输入不是xml过滤掉 直接 返回结果；
  171.      
  172.         XmlDocument xml = new XmlDocument();
  173.         XmlReaderSettings set = new XmlReaderSettings();
  174.         set.IgnoreComments = true;
  175.         xml.LoadXml(strxml);
  176.  
  177.         int s_confidenct = 0;
  178.         string s_rawtext = "";
  179.         int d_confidenct = 0;
  180.         string d_focus = "";
  181.         double res = 0;
  182.  
  183.         XmlNodeList sour_xmlNodeList = xml.SelectSingleNode("nlp").ChildNodes;
  184.         foreach (XmlElement node in sour_xmlNodeList)
  185.         {
  186.             if (node.Name == "confidence")
  187.             {
  188.                 s_confidenct = int.Parse(node.InnerText.Trim());
  189.                 print(node.Name + ":" + s_confidenct);
  190.             }
  191.             if (node.Name == "rawtext")
  192.             {
  193.                 s_rawtext = node.InnerText.Trim();
  194.                 print(node.Name + ":" + s_rawtext);
  195.             }
  196.         }
  197.  
  198.         XmlNodeList back_dst_xmlNodeList = xml.SelectSingleNode("nlp").SelectSingleNode("result").ChildNodes;
  199.         foreach (XmlElement node in back_dst_xmlNodeList)
  200.         {
  201.             if (node.Name == "confidence")
  202.             {
  203.                 d_confidenct = int.Parse(node.InnerText.Trim());
  204.                 print(node.Name + ":" + d_confidenct);
  205.             }
  206.             if (node.Name == "focus")
  207.             {
  208.                 d_focus = node.InnerText.Trim();
  209.                 print(node.Name + ":" + d_focus);
  210.             }
  211.         }
  212.  
  213.         if (s_confidenct > confidenct)//识别置信度调节
  214.         {
  215.          send_speech_result(d_focus, s_confidenct);
  216.         }
  217.  
  218.         return res;  //返回匹配相似度；
  219.     }
  220.  
  221.     //功能：向父脚本子脚本广播识别结果
  222.     //传入：1.结果文本|2.置信度|3.计算的匹配率 0~1 之间的浮点数
  223.     void send_speech_result(string focus, int percent)
  224.     {
  225.  
  226.         listening_off = false;
  227.         free_msp();//临时退出登录
  228.         if (Equals(focus, "小微") || Equals(focus, "小微小微"))
  229.         {
  230.           speech_tts("在的");
  231.           init_listing();
  232.           return;
  233.         }
  234.         speech_tts(focus);
  235.         init_listing();
  236.  
  237.         //以下是将语音识别结果广播给其他节点
  238.         object[] message = new object[2];
  239.         message[0] = focus;
  240.         message[1] = percent;
  241.         this.gameObject.SendMessage("speech_result", message, SendMessageOptions.DontRequireReceiver);
  242.         this.gameObject.BroadcastMessage("speech_result", message, SendMessageOptions.DontRequireReceiver);
  243.     }
  244.  
  245. /
  246.  
  247.  
  248. }

4.Unity创建 节点1 2D Sprinte 节点2 Audio Audio source  将节点2拖拽到节点1 Inspector面板 Aud节点实现引用关联。

5.该应用使用命令词实现了类似本地唤醒功能，软件运行后一直update 麦克风，监听到命令响应在的 或做其他命令处理。

6.语音合成WAV文件，做了本地保存，反复调用直接读取本地文件，不用反复使用TTS作文字到语音的转换，以节省资源。

步骤九

巴科斯范式.bnf文件可以关注这里巴科斯范式详解，这里简化了命令词定义用于测试。

  1. #BNF+IAT 1.0;
  2. !grammar call;
  3.  
  4. !start <callstart>;
  5. <callstart>:syj|小微小微|小微|向前走|下一步|hello|你好|您
  6. 好|小螺丝|星际迷航|大陆|今天太冷了;

步骤九

问题总结

1，两个离线引擎不能同时运行，所以上面实现的是交替运行模式  就是识别模块运行，朗读模块初始化会失败，反之亦然，这样导致灵活性不强，不确定问题在哪里，也可能是引用了一个msc_x64.dll文件，这里不太确定，unity目录引用原因未能做测试，期待解决方案。

2.离线命令词识别返回结果会有1-3秒的识别反应时间，才能返回结果 ，这个时间可以做一个语音回馈，但是没有返回结果就不能确定是否应该触发语音回馈，期待解决方案。

3.语音合成朗读速度很快，可以放心使用。

4.以上测试文件打包，有需要可以自行下载。

https://download.csdn.net/download/lijiefu123456/13098984

 

 

 

 

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/124098
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号