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

2023年5月27日下午12:25 • 人工智能 • 阅读 207

步骤一

登录iFLYTEK平台注册并创建您自己的应用程序

[En]

Log in to iFLYTEK platform to register and create your own application

https://www.xfyun.cn

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

步骤二

下载离线命令词识别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

/*
* 语音合成（Text To Speech，TTS）技术能够自动将任意文字实时转换为连续的
* 自然语音是一种语音消息服务，可以随时随地向任何人提供。<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>* Natural voice is a kind of voice message service that can be provided to anyone at any time, anywhere.</font>*</details>
* 高效便捷的手段，与信息时代海量数据、动态更新、个性化查询的需求非常契合。<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>* efficient and convenient means, which are very consistent with the needs of massive data, dynamic updates and personalized queries in the information age.</font>*</details>
*/

#include
#include
#include
#include

#include
#include
#include

#include "qtts.h"
#include "msp_cmn.h"
#include "msp_errors.h"

#ifdef _WIN64
#pragma comment(lib,"../../libs/msc_x64.lib")//x64
#else
#pragma comment(lib,"../../libs/msc.lib")//x86
#endif

/* wav音频头部格式 */
typedef struct _wave_pcm_hdr
{
    char            riff[4];                // = "RIFF"
    int                size_8;                 // = FileSize - 8
    char            wave[4];                // = "WAVE"
    char            fmt[4];                 // = "fmt "
    int                fmt_size;                // = 下一个结构体的大小 : 16

    short int       format_tag;             // = PCM : 1
    short int       channels;               // = 通道数 : 1
    int                samples_per_sec;        // = 采样率 : 8000 | 6000 | 11025 | 16000
    int                avg_bytes_per_sec;      // = 每秒字节数 : samples_per_sec * bits_per_sample / 8
    short int       block_align;            // = 每采样点字节数 : wBitsPerSample / 8
    short int       bits_per_sample;        // = 量化比特数: 8 | 16

    char            data[4];                // = "data";
    int                data_size;              // = 纯数据长度 : FileSize - 44 
} wave_pcm_hdr;

/* 默认wav音频头部数据 */
wave_pcm_hdr default_wav_hdr = 
{
    { 'R', 'I', 'F', 'F' },
    0,
    {'W', 'A', 'V', 'E'},
    {'f', 'm', 't', ' '},
    16,
    1,
    1,
    16000,
    32000,
    2,
    16,
    {'d', 'a', 't', 'a'},
    0  
};

char *wchar_t_to_char(const wchar_t *str){
    char *result = NULL;
    int textlen = 0;
    textlen = WideCharToMultiByte(CP_ACP,0,str,-1,NULL,0,NULL,NULL);
    result = (char*)malloc((textlen+1)*sizeof(char));
    memset(result,0,sizeof(char)*(textlen+1));
    WideCharToMultiByte(CP_ACP,0,str,-1,result,textlen,NULL,NULL);
    return result;
}

/* 文本合成 */
int text_to_speech(const char* src_text, const char* des_path, const char* params)
{
    int          ret          = -1;
    FILE*        fp           = NULL;
    const char*  sessionID    = NULL;
    unsigned int audio_len    = 0;
    wave_pcm_hdr wav_hdr      = default_wav_hdr;
    int          synth_status = MSP_TTS_FLAG_STILL_HAVE_DATA;

    if (NULL == src_text || NULL == des_path)
    {
        printf("params is error!\n");
        return 0;
    }
    fp = fopen(des_path, "wb");
    if (NULL == fp)
    {
        printf("open %s error.\n", des_path);
        return 1;
    }
    /* 开始合成 */
    sessionID = QTTSSessionBegin(params, &ret);
    if (MSP_SUCCESS != ret)
    {
        printf("QTTSSessionBegin failed, error code: %d.\n", ret);
        fclose(fp);
        return 2;
    }
    ret = QTTSTextPut(sessionID, src_text, (unsigned int)strlen(src_text), NULL);
    if (MSP_SUCCESS != ret)
    {
        printf("QTTSTextPut failed, error code: %d.\n",ret);
        QTTSSessionEnd(sessionID, "TextPutError");
        fclose(fp);
        return 3;
    }
    printf("正在合成 ...\n");
    fwrite(&wav_hdr, sizeof(wav_hdr) ,1, fp); //添加wav音频头，使用采样率为16000
    while (1) 
    {
        /* 获取合成音频 */
        const void* data = QTTSAudioGet(sessionID, &audio_len, &synth_status, &ret);
        if (MSP_SUCCESS != ret)
            break;
        if (NULL != data)
        {
            fwrite(data, audio_len, 1, fp);
            wav_hdr.data_size += audio_len; //计算data_size大小
        }
        if (MSP_TTS_FLAG_DATA_END == synth_status)
            break;
    }
    printf("\n");
    if (MSP_SUCCESS != ret)
    {
        printf("QTTSAudioGet failed, error code: %d.\n",ret);
        QTTSSessionEnd(sessionID, "AudioGetError");
        fclose(fp);
        return 4;
    }
    /* 修正wav文件头数据的大小 */
    wav_hdr.size_8 += wav_hdr.data_size + (sizeof(wav_hdr) - 8);

    /* 将修正过的数据写回文件头部,音频文件为wav格式 */
    fseek(fp, 4, 0);
    fwrite(&wav_hdr.size_8,sizeof(wav_hdr.size_8), 1, fp); //写入size_8的值
    fseek(fp, 40, 0); //将文件指针偏移到存储data_size值的位置
    fwrite(&wav_hdr.data_size,sizeof(wav_hdr.data_size), 1, fp); //写入data_size的值
    fclose(fp);
    fp = NULL;
    /* 合成完毕 */
    ret = QTTSSessionEnd(sessionID, "Normal");
    if (MSP_SUCCESS != ret)
    {
        printf("QTTSSessionEnd failed, error code: %d.\n",ret);
    }

    return 5;
}

/* 用户登录 */
__declspec(dllexport)  int loading_tts(){
    int         ret                  = MSP_SUCCESS;
    const char* login_params         = "appid = 替换自己的appid, work_dir = .";//登录参数,appid与msc库绑定,请勿随意改动
    ret = MSPLogin(NULL, NULL, login_params); //第一个参数是用户名，第二个参数是密码，第三个参数是登录参数，用户名和密码可在http://www.xfyun.cn注册获取
    if (MSP_SUCCESS != ret)
    {
        MSPLogout(); 
        return 0;
    }
    return 1;
}

/* 开始转换 */
__declspec(dllexport)  int to_speech(wchar_t * wav_path, wchar_t * tts_text){
    int         ret                  = MSP_SUCCESS;
    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";
    //const char* filename             = "C:\\xunfei_speech\\tts_sample.wav"; //合成的语音文件名称s
    //const char* text                 = "亲爱的用户，您好，这是一个语音合成示例，感谢您对小螺丝语音技术的支持！小螺丝是亚太地区最大的上市公司，股票代码：002233"; //合成文本
    const char* filename             =wchar_t_to_char(wav_path);
    const char* text                 =wchar_t_to_char(tts_text);
    ret = text_to_speech(text, filename, session_begin_params);
    return ret;
}

/* 释放 */
__declspec(dllexport)  int free_tts(){
   MSPLogout(); 
   return 1;
}

3.重新生成DLL

步骤七

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

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

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

/*
* 语音听写(iFly Auto Transform)技术能够实时地将语音转换成对应的文字。
*/

#include
#include
//#include

#include
#include
#include
#include

#include "../../include/qisr.h"
#include "../../include/msp_cmn.h"
#include "../../include/msp_errors.h"
#include "./include/speech_recognizer.h"

#define FRAME_LEN   640
#define BUFFER_SIZE 4096

enum{
    EVT_START = 0,
    EVT_STOP,
    EVT_QUIT,
    EVT_TOTAL
};
static HANDLE events[EVT_TOTAL] = {NULL,NULL,NULL};

static COORD begin_pos = {0, 0};
static COORD last_pos = {0, 0};
#define SAMPLE_RATE_16K     (16000)
#define SAMPLE_RATE_8K      (8000)
#define MAX_GRAMMARID_LEN   (32)
#define MAX_PARAMS_LEN      (1024)

const char * ASR_RES_PATH        = "fo|C:\\xunfei_speech\\command_speech\\common.jet";  //离线语法识别资源路径
#ifdef _WIN64
const char * GRM_BUILD_PATH      = "C:\\xunfei_speech\\command_speech\\GrmBuilld_x64";  //构建离线语法识别网络生成数据保存路径
#else
const char * GRM_BUILD_PATH      = "C:\\xunfei_speech\\command_speech\\GrmBuilld";  //构建离线语法识别网络生成数据保存路径
#endif
const char * GRM_FILE            = "C:\\xunfei_speech\\command_speech\\call.bnf"; //构建离线识别语法网络所用的语法文件
const char * LEX_NAME            = "contact"; //更新离线识别语法的contact槽（语法文件为此示例中使用的call.bnf）
typedef struct _UserData {
    int     build_fini;  //标识语法构建是否完成
    int     update_fini; //标识更新词典是否完成
    int     errcode; //记录语法构建或更新词典回调错误码
    char    grammar_id[MAX_GRAMMARID_LEN]; //保存语法构建返回的语法ID
}UserData;

const char *get_audio_file(void); //选择进行离线语法识别的语音文件
int build_grammar(UserData *udata); //构建离线识别语法网络
int update_lexicon(UserData *udata); //更新离线识别语法词典
int run_asr(UserData *udata); //进行离线语法识别

int build_grm_cb(int ecode, const char *info, void *udata)
{
    UserData *grm_data = (UserData *)udata;

    if (NULL != grm_data) {
        grm_data->build_fini = 1;
        grm_data->errcode = ecode;
    }

    if (MSP_SUCCESS == ecode && NULL != info) {
        printf("构建语法成功！ 语法ID:%s\n", info);
        if (NULL != grm_data)
            _snprintf(grm_data->grammar_id, MAX_GRAMMARID_LEN - 1, info);
    }
    else
        printf("构建语法失败！%d\n", ecode);

    return 0;
}

int build_grammar(UserData *udata)
{
    FILE *grm_file                           = NULL;
    char *grm_content                        = NULL;
    unsigned int grm_cnt_len                 = 0;
    char grm_build_params[MAX_PARAMS_LEN]    = {NULL};
    int ret                                  = 0;

    grm_file = fopen(GRM_FILE, "rb");
    if(NULL == grm_file) {
        printf("打开\"%s\"文件失败！[%s]\n", GRM_FILE, strerror(errno));
        return -1;
    }

    fseek(grm_file, 0, SEEK_END);
    grm_cnt_len = ftell(grm_file);
    fseek(grm_file, 0, SEEK_SET);

    grm_content = (char *)malloc(grm_cnt_len + 1);
    if (NULL == grm_content)
    {
        printf("内存分配失败!\n");
        fclose(grm_file);
        grm_file = NULL;
        return -1;
    }
    fread((void*)grm_content, 1, grm_cnt_len, grm_file);
    grm_content[grm_cnt_len] = '\0';
    fclose(grm_file);
    grm_file = NULL;

    _snprintf(grm_build_params, MAX_PARAMS_LEN - 1,
        "engine_type = local, \
        asr_res_path = %s, sample_rate = %d, \
        grm_build_path = %s, ",
        ASR_RES_PATH,
        SAMPLE_RATE_16K,
        GRM_BUILD_PATH
        );
    ret = QISRBuildGrammar("bnf", grm_content, grm_cnt_len, grm_build_params, build_grm_cb, udata);

    free(grm_content);
    grm_content = NULL;

    return ret;
}

int update_lex_cb(int ecode, const char *info, void *udata)
{
    UserData *lex_data = (UserData *)udata;

    if (NULL != lex_data) {
        lex_data->update_fini = 1;
        lex_data->errcode = ecode;
    }

    if (MSP_SUCCESS == ecode)
        printf("更新词典成功！\n");
    else
        printf("更新词典失败！%d\n", ecode);

    return 0;
}

int update_lexicon(UserData *udata)
{
    const char *lex_content                   = "丁伟\n黄辣椒";
    unsigned int lex_cnt_len                  = strlen(lex_content);
    char update_lex_params[MAX_PARAMS_LEN]    = {NULL};

    _snprintf(update_lex_params, MAX_PARAMS_LEN - 1,
        "engine_type = local, text_encoding = GB2312, \
        asr_res_path = %s, sample_rate = %d, \
        grm_build_path = %s, grammar_list = %s, ",
        ASR_RES_PATH,
        SAMPLE_RATE_16K,
        GRM_BUILD_PATH,
        udata->grammar_id);
    return QISRUpdateLexicon(LEX_NAME, lex_content, lex_cnt_len, update_lex_params, update_lex_cb, udata);
}

static void show_result(char *string, char is_over)
{
    COORD orig, current;
    CONSOLE_SCREEN_BUFFER_INFO info;
    HANDLE w = GetStdHandle(STD_OUTPUT_HANDLE);
    GetConsoleScreenBufferInfo(w, &info);
    current = info.dwCursorPosition;

    if(current.X == last_pos.X && current.Y == last_pos.Y ) {
        SetConsoleCursorPosition(w, begin_pos);
    } else {
        /* changed by other routines, use the new pos as start */
        begin_pos = current;
    }
    if(is_over)
        SetConsoleTextAttribute(w, FOREGROUND_GREEN);
    printf("Result: [ %s ]\n", string);
    if(is_over)
        SetConsoleTextAttribute(w, info.wAttributes);

    GetConsoleScreenBufferInfo(w, &info);
    last_pos = info.dwCursorPosition;
}

static char *g_result = NULL;  //

static char bk_result[1024]="0";

static unsigned int g_buffersize = BUFFER_SIZE;
static UserData g_asr_data;
struct speech_rec g_asr;

void on_result(const char *result, char is_last)
{
    if (result) {
        size_t left = g_buffersize - 1 - strlen(g_result);
        size_t size = strlen(result);
        if (left < size) {
            g_result = (char*)realloc(g_result, g_buffersize + BUFFER_SIZE);
            if (g_result)
                g_buffersize += BUFFER_SIZE;
            else {
                printf("mem alloc failed\n");
                return;
            }
        }

        strncat(g_result, result, size);
        printf(g_result);
        strcpy(bk_result,g_result);

        //show_result(g_result, is_last);
    }
}
void on_speech_begin()
{
    if (g_result)
    {
        free(g_result);
    }

    g_result = (char*)malloc(BUFFER_SIZE);
    g_buffersize = BUFFER_SIZE;
    memset(g_result, 0, g_buffersize);
    printf("Start Listening...\n");

}
void on_speech_end(int reason)
{
    if (reason == END_REASON_VAD_DETECT){
        printf("\nSpeaking done \n");
       // g_result = (char*)"Speaking done";
        //strcpy(bk_result,"Speaking done");
    }else{
        printf("\nRecognizer error %d\n", reason);
        //g_result = (char*)"Recognizer error";
        //strcpy(bk_result,"Recognizer error");
    }
}

/* demo recognize the audio from microphone */
static void recognize_mic(const char* session_begin_params)
{
    int errcode;
    int i = 0;
    HANDLE helper_thread = NULL;

    DWORD waitres;
    char isquit = 0;

    struct speech_rec_notifier recnotifier = {
        on_result,
        on_speech_begin,
        on_speech_end
    };

    errcode = sr_init(&g_asr, session_begin_params, SR_MIC, DEFAULT_INPUT_DEVID, &recnotifier);
    if (errcode) {
        printf("speech recognizer init failed\n");
        return;
    }
}

int run_asr(UserData *udata)
{
    char asr_params[MAX_PARAMS_LEN]    = {NULL};
    const char *rec_rslt               = NULL;
    const char *session_id             = NULL;
    const char *asr_audiof             = NULL;
    FILE *f_pcm                        = NULL;
    char *pcm_data                     = NULL;
    long pcm_count                     = 0;
    long pcm_size                      = 0;
    int last_audio                     = 0;
    int aud_stat                       = MSP_AUDIO_SAMPLE_CONTINUE;
    int ep_status                      = MSP_EP_LOOKING_FOR_SPEECH;
    int rec_status                     = MSP_REC_STATUS_INCOMPLETE;
    int rss_status                     = MSP_REC_STATUS_INCOMPLETE;
    int errcode                        = -1;
    int aud_src                        = 1;

    //离线语法识别参数设置
    _snprintf(asr_params, MAX_PARAMS_LEN - 1,
        "engine_type = local, \
        asr_res_path = %s, sample_rate = %d, \
        grm_build_path = %s, local_grammar = %s, \
        result_type = xml, result_encoding = GB2312, ",
        ASR_RES_PATH,
        SAMPLE_RATE_16K,
        GRM_BUILD_PATH,
        udata->grammar_id
        );

        recognize_mic(asr_params);

    return 0;
}

int main(int argc, char* argv[]){
    const char *login_config    = "appid = 5fa0d519"; //登录参数
    int ret                    = 0 ;
    ret = MSPLogin(NULL, NULL, login_config); //第一个参数为用户名，第二个参数为密码，传NULL即可，第三个参数是登录参数
    if (MSP_SUCCESS != ret) {
        printf("登录失败：%d\n", ret);
        //goto exit;
    }

    memset(&g_asr_data, 0, sizeof(UserData));
    printf("构建离线识别语法网络...\n");
    ret = build_grammar(&g_asr_data);  //第一次使用某语法进行识别，需要先构建语法网络，获取语法ID，之后使用此语法进行识别，无需再次构建
    if (MSP_SUCCESS != ret) {
        printf("构建语法调用失败！\n");
    }

    while (1 != g_asr_data.build_fini)
        _sleep(300);
    if (MSP_SUCCESS != g_asr_data.errcode)
    printf("离线识别语法网络构建完成，开始识别...\n");

    ret = run_asr(&g_asr_data);
    if (MSP_SUCCESS != ret) {
        printf("离线语法识别出错: %d \n", ret);
    }
    while(1){
    sr_start_listening(&g_asr);
    _sleep(1000);
    }
    return 1;
}

//初始化登录
__declspec(dllexport)  int loading_msp(){
    const char *login_config    = "appid = 替换自己的appid"; //登录参数
    int ret                    = 0 ;
    ret = MSPLogin(NULL, NULL, login_config); //第一个参数为用户名，第二个参数为密码，传NULL即可，第三个参数是登录参数
    if (MSP_SUCCESS != ret) {
        MSPLogout();
        return 0;
    }
    memset(&g_asr_data, 0, sizeof(UserData));
    return 1;
}

/* 构建命令词网络 */
__declspec(dllexport)  int build_net_msp(){
    int ret                    = 0 ;
    printf("构建离线识别语法网络...\n");
    ret = build_grammar(&g_asr_data);  //第一次使用某语法进行识别，需要先构建语法网络，获取语法ID，之后使用此语法进行识别，无需再次构建
    if (MSP_SUCCESS != ret) {
        printf("构建语法调用失败！\n");
        return -1;
    }
    while (1 != g_asr_data.build_fini)
        _sleep(300);
    if (MSP_SUCCESS != g_asr_data.errcode)
        return 0;
    return 1;
}

/* 更新词典槽 */
__declspec(dllexport)  int update_lexicon_msp(){
    int ret                    = 0 ;
    printf("更新离线语法词典...\n");
    ret = update_lexicon(&g_asr_data);  //当语法词典槽中的词条需要更新时，调用QISRUpdateLexicon接口完成更新
    if (MSP_SUCCESS != ret) {
        printf("更新词典调用失败！\n");
        return 0;
    }
    while (1 != g_asr_data.update_fini)
        _sleep(300);
    if (MSP_SUCCESS != g_asr_data.errcode)
        return 0;
    return 1;
}

/* 识别命令词 */
__declspec(dllexport)  int init_run_msp(){
    int ret                    = 0 ;
    ret = run_asr(&g_asr_data);
    if (MSP_SUCCESS != ret) {
        printf("离线语法识别出错: %d \n", ret);
        return 0;
    }
    return 1;
}

static wchar_t * char2wchar(char *str){
    int length = strlen(str)+1;
    wchar_t *t = (wchar_t*)malloc(sizeof(wchar_t)*length);
    memset(t,0,length*sizeof(wchar_t));
    MultiByteToWideChar(CP_ACP,0,str,strlen(str),t,length);
    return t;
}

/* 识别命令词 */
__declspec(dllexport) wchar_t* start_listening(){

    wchar_t* re;
    if (sr_start_listening(&g_asr)!=NULL){
    // char * str1 = "小螺丝科技有限公司hahah1523";//g_result
    }
    re = char2wchar(bk_result);
    strcpy(bk_result,"0");
    return re;
}

/* 释放 */
__declspec(dllexport)  int free_msp(){
    MSPLogout();
    return 1;
}

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，脚本代码如下：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using System;
using System.Text;
using System.Linq;
using System.IO;
using System.Xml;

using System.Runtime.InteropServices;

public class ToSpeech : MonoBehaviour
{

     //初始化TTS离线朗读语音引擎
    [DllImport("tts_offline_sample", EntryPoint = "loading_tts", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    extern static int loading_tts();
    //合成语音文件
    [DllImport("tts_offline_sample", EntryPoint = "to_speech", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    extern static int to_speech([MarshalAs(UnmanagedType.LPWStr)]string wav_path, [MarshalAs(UnmanagedType.LPWStr)]string tts_text);
    //释放TTS朗读语音引擎
    [DllImport("tts_offline_sample", EntryPoint = "free_tts", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    extern static int free_tts();

    //初始化命令词识别离线引擎
    [DllImport("asr_offline_record_sample", EntryPoint = "loading_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    public static extern int loading_msp();
    //初始化预热识别
    [DllImport("asr_offline_record_sample", EntryPoint = "init_run_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    static extern int init_run_msp();
    //构建识别网络
    [DllImport("asr_offline_record_sample", EntryPoint = "build_net_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    static extern int build_net_msp();
    //更新词典槽
    [DllImport("asr_offline_record_sample", EntryPoint = "update_lexicon_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    static extern int update_lexicon_msp();
     //开启监听——micphone
    [DllImport("asr_offline_record_sample", EntryPoint = "start_listening", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    static extern IntPtr start_listening();
    //释放命令词识别离线引擎
    [DllImport("asr_offline_record_sample", EntryPoint = "free_msp", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    static extern int free_msp();

    //test
    //[DllImport("asr_offline_record_sample", EntryPoint = "test", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    //public static extern int test();

    public bool listening_off = false; //监听器循环开启关闭开关
    public int confidenct = 25; //置信度调节
    private int tts_off = 0;
    private float lastTime;
    private float curTime;

    void Start()
    {
       init_listing();
    }

    void Update()
    {
      update_listing();
    }

//讲述人///

    public AudioSource aud;//需要节点关联

    IEnumerator LoadAudio(string recordPath)
    {
        WWW www = new WWW(recordPath);
        yield return www;
        var clipTemp = www.GetAudioClip();
        aud.clip = clipTemp;
        aud.Play();
    }

    private void speech_tts(string tts_text)
    {

        string wav_path = @"C:\\xunfei_speech\\" + tts_text + ".wav";
        if (File.Exists(wav_path))
        {
            StartCoroutine(LoadAudio(wav_path));
            return;
        }
        //如果文件已经生成就不用在合成了，直接读取播放

        tts_off = loading_tts();
        if (tts_off == 1)
        {
            print("初始化朗读成功：" + tts_off);
            int ret2 = to_speech(wav_path, tts_text);
            StartCoroutine(LoadAudio(wav_path));
        }
        else
        {
            print("初始化失败：" + tts_off);
        }
        free_tts();
    }

/聆听人//

    //功能：初始化监听器
    void init_listing()
    {
        if (1 == loading_msp())
        {
            print("载入初始化成功");
            //实际应用中只执行一次///
            if (1 == build_net_msp())
            {
                print("下载构建网络命令词成功");
                if (1 == update_lexicon_msp())
                {
                   print("更新词典槽成功");
                }
            }

            if (1 == init_run_msp())
            {
                print("预热命令词成功");
                listening_off = true;
            }
        }
        lastTime = Time.time;
    }

    //功能：循环发送mic监听器开启，可以重复发送，sdk 做了同步处理
    //返回：xml格式数据
    string update_listing()
    {
        string restr = "0";
        curTime = Time.time;
        if (curTime - lastTime >= 1)
        {
            if (listening_off)
            {
                IntPtr ip = start_listening();
                restr = Marshal.PtrToStringUni(ip);
                print("打开麦克风监听中..." + restr);
                get_result_confidenct(restr);//解析xml
            }
           // print(curTime - lastTime);
            lastTime = curTime;
        }
        return restr;
    }

    //功能：释放监听器
    void OnDestroy(){
        free_msp();
        print("退出了");
    }

    //功能：语音识别结果返回xml解析
    //传入：xml字符串；
    //返回：置信度结果，是一个0~1的浮点类型数字；
    double get_result_confidenct(string strxml)
    {
        // string strxml = @"  1.1  您好  27  local      您好    18          您好      ";
        if (Equals(strxml,"0")) { return 0; }  //输入不是xml过滤掉 直接 返回结果；

        XmlDocument xml = new XmlDocument();
        XmlReaderSettings set = new XmlReaderSettings();
        set.IgnoreComments = true;
        xml.LoadXml(strxml);

        int s_confidenct = 0;
        string s_rawtext = "";
        int d_confidenct = 0;
        string d_focus = "";
        double res = 0;

        XmlNodeList sour_xmlNodeList = xml.SelectSingleNode("nlp").ChildNodes;
        foreach (XmlElement node in sour_xmlNodeList)
        {
            if (node.Name == "confidence")
            {
                s_confidenct = int.Parse(node.InnerText.Trim());
                print(node.Name + ":" + s_confidenct);
            }
            if (node.Name == "rawtext")
            {
                s_rawtext = node.InnerText.Trim();
                print(node.Name + ":" + s_rawtext);
            }
        }

        XmlNodeList back_dst_xmlNodeList = xml.SelectSingleNode("nlp").SelectSingleNode("result").ChildNodes;
        foreach (XmlElement node in back_dst_xmlNodeList)
        {
            if (node.Name == "confidence")
            {
                d_confidenct = int.Parse(node.InnerText.Trim());
                print(node.Name + ":" + d_confidenct);
            }
            if (node.Name == "focus")
            {
                d_focus = node.InnerText.Trim();
                print(node.Name + ":" + d_focus);
            }
        }

        if (s_confidenct > confidenct)//识别置信度调节
        {
         send_speech_result(d_focus, s_confidenct);
        }

        return res;  //返回匹配相似度；
    }

    //功能：向父脚本子脚本广播识别结果
    //传入：1.结果文本|2.置信度|3.计算的匹配率 0~1 之间的浮点数
    void send_speech_result(string focus, int percent)
    {

        listening_off = false;
        free_msp();//临时退出登录
        if (Equals(focus, "小微") || Equals(focus, "小微小微"))
        {
          speech_tts("在的");
          init_listing();
          return;
        }
        speech_tts(focus);
        init_listing();

        //以下是将语音识别结果广播给其他节点
        object[] message = new object[2];
        message[0] = focus;
        message[1] = percent;
        this.gameObject.SendMessage("speech_result", message, SendMessageOptions.DontRequireReceiver);
        this.gameObject.BroadcastMessage("speech_result", message, SendMessageOptions.DontRequireReceiver);
    }

/

}

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

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

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

步骤九

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

#BNF+IAT 1.0;
!grammar call;

!start ;
:syj|小微小微|小微|向前走|下一步|hello|你好|您
好|小螺丝|星际迷航|大陆|今天太冷了;

步骤九

问题总结

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

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

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

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

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

Original: https://blog.csdn.net/lijiefu123456/article/details/109568797
Author: 神奇元创
Title: 讯飞离线语音命令词+TTS离线发音，实现命令词交互（windows dll for unity插件）

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/526110/

转载文章受原作者版权保护。转载请注明原作者出处！

人工智能

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

脑电EEG代码开源分享【4.特征提取-频域篇】

往期文章希望了解更多的道友点这里0. 分享【脑机接口 + 人工智能】的学习之路1.1 . 脑电EEG代码开源分享【1.前置准备-静息态篇】1.2 . 脑电EEG代码开源分享【…

人工智能 2023年7月27日
0074
目标检测发展路程(一)——Two stage

目标检测是计算机视觉领域中非常重要的一个研究方向，它是将图像或者视频中目标与其他不感兴趣的部分进行区分，判断是否存在目标，确定目标位置，识别目标种类的任务，即定位+分类。传统的目标…

人工智能 2023年7月12日
0098
机器学习实战——4.5 使用Python进行文本分类

目录 1. 准备数据：从文本中构建词向量 1.1 词表到向量的转换函数 2. 训练算法：从词向量计算概率 3. 测试算法：根据现实情况修改分类器 3.1 朴素贝叶斯分类函数 4. …

人工智能 2023年7月1日
0098
德国iF多项大奖加冕，这副耳机有多强？音珀GTW 270 Hybrid深度评测

传统耳机和电竞耳机，我们一般都是有针对性的选择，毕竟市场可以二合一，而且两方面打出优秀的耳机产品并不多，而对于电竞耳机，尤其是电脑PC游戏，大多以耳机为主，相对而言，耳机对于游戏音…

人工智能 2023年5月23日
0076
从Hadder看蛋白质分子中的加氢算法

技术背景 PDB（Protein Data Bank）是一种最常用于存储蛋白质结构的文件。而我们在研究蛋白质构象时，往往更多的是考虑其骨架，因此在很多pdb文件中直接去掉了氢原子。…

人工智能 2023年6月4日
0079
MAE源代码理解 part2 ：预训练调试

目录 1 事先准备二调试用MAE预训练的模型用于自己下游的分类 part1 ： MAE源代码理解 part1 ：调试理解法_YI_SHU_JIA的博客-CSDN博客 git…

人工智能 2023年6月23日
0079
关于VIO零速更新(ZUPT)与控制三种约束的工程实践

今天这篇是深度稍微高一些的，尽量写细，但是具体实践各家都有不同的方式与工程习惯，就不多赘述了。小组工作比较忙，代码还没来得及整理，总体更新一下基础知识。 VIO系统后端核心的三种…

人工智能 2023年6月18日
0088
python导入、导出csv文件的方法

python 导入csv文件的方法 pd.read_csv（）几个常用参数： filepath_or_buffer :文件路径 header:指定哪一行为列名 index_col:…

人工智能 2023年7月6日
00154
【pytorch】1.4 tensor.view()、tensor.reshape()、tensor.resize_() 三者的区别

目录 1、Tensor 内部存储结构 * 1. 1 tensor 的步长属性: stride() 1. 2 tensor 的偏移属性：storage_offset() 1.3 存储…

人工智能 2023年7月23日
0074
数字图像处理复习

抵扣说明： 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。2.余额无法直接购买下载，可以购买VIP、C币套餐、付费专栏及课程。 Original: https:…

人工智能 2023年6月20日
0083
【Python】：SIFT算法的实现

✨博客主页：米开朗琪罗~🎈✨博主爱好：羽毛球🏸✨年轻人要：Living for the moment（活在当下）！💪🏆推荐专栏：【图像处理】【千锤百炼Python】【深度学习】【排…

人工智能 2023年6月18日
0085
多分类决策树 r语言_R语言 | 多分类建模+ROC曲线绘制

大家好，我是菜鸟君。之前提到过R语言分类模型构建，以及R语言绘制ROC曲线的方法。然后在后台收到小伙伴的留言：我才意识到，确实是我之前考虑的不周到，只考虑到视频时长的原因，所以拆…

人工智能 2023年7月3日
0085
人工智能起步-反向回馈神经网路算法（BP算法）

本文出处人工智能分为强人工，弱人工。弱人工智能就包括我们常用的语音识别，图像识别等，或者为了某一个固定目标实现的人工算法，如：下围棋，游戏的AI，聊天机器人，阿尔法狗等。强人…

人工智能 2023年6月4日
0097
dataframe普通切片与loc，iloc选取数据

import pandas as pd import numpy as np url = ‘https://raw.githubusercontent.com/HoijanLai/…

人工智能 2023年7月7日
0083
好像还挺好玩的GAN重制版4——Pytorch搭建SRGAN平台进行图片超分辨率提升

好像还挺好玩的GAN重制版4——Pytorch搭建SRGAN平台进行图片超分辨率提升学习前言源码下载地址网络构建 * 一、什么是SRGAN 二、生成网络的构建三、判别网络的…

人工智能 2023年6月16日
00106
【Pandas】DataFrame数据的增删改

DataFrame数据的增删改 DataFrame增加数据 * 增加一行增加列 – 根据原有数据增加列 DataFrame修改数据 * 修改单个数据修改一列数据 D…

人工智能 2023年7月6日
0050

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

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

大家都在看