C++ 如何使用espeak_事件_类型；

我正在寻找一种方法来知道espeak的结束时间，它正在说话。有人告诉我使用

espeakEVENT\u MSG\u

。但是，当我尝试将此部分放入代码时，会出现以下错误：

#include <espeak/speak_lib.h>

espeak_EVENT_TYPE;

    if( espeak_EVENT_TYPE == espeakEVENT_MSG_TERMINATED)
    {
    do something;
    }

编辑2：

#include <stdio.h>
#include <string.h>
#include <assert.h>

#include <sphinxbase/err.h>
#include <sphinxbase/ad.h>

#include <espeak/speak_lib.h>
#include <string>
#include <iostream>
using namespace std;

#include "pocketsphinx.h"
static ps_decoder_t *ps;
static cmd_ln_t *config;
static FILE *rawfd;

ad_rec_t *ad;

espeak_POSITION_TYPE position_type;
espeak_AUDIO_OUTPUT output;
char *path=NULL;
int Buflength = 1000, Options=0;
void* user_data;
char Voice[] = {"English"};
unsigned int Size,position=0, end_position=0, flags=espeakCHARS_AUTO, *unique_identifier;
t_espeak_callback *SynthCallback;
espeak_PARAMETER Parm;

static void initFuncs()
{

    output = AUDIO_OUTPUT_PLAYBACK;
    espeak_Initialize(output, Buflength, path, AUDIO_OUTPUT_SYNCHRONOUS ); 
    espeak_SetVoiceByName(Voice);
    const char *langNativeString = "en";
    espeak_VOICE voice;
    memset(&voice, 0, sizeof(espeak_VOICE));
        voice.languages = langNativeString;
        voice.name = "US";
        voice.variant = 2;
        voice.gender = 1;
        espeak_SetVoiceByProperties(&voice);

}

int receive_espeak_events(short *wav, int numsamples, espeak_EVENT *event)
{
    while (event->type != espeakEVENT_LIST_TERMINATED) {
        if (event->type == espeakEVENT_MSG_TERMINATED) {
            /* do something */
            ad_start_rec(ad);
        }
        ++event; // Examine the next event.
    }
    return 0; // Continue speaking.
}

static void sleep_msec(int32 ms)
{
    struct timeval tmo;

    tmo.tv_sec = 0;
    tmo.tv_usec = ms * 1000;

    select(0, NULL, NULL, NULL, &tmo);

}

static void speech(char* hyp)
{      
    Size = strlen(hyp)+1;
    espeak_SetSynthCallback(receive_espeak_events);
    espeak_Synth( hyp, Size, position, position_type, end_position, flags,unique_identifier, user_data );
    espeak_Synchronize( );    
}


static void recognize_from_microphone()
{

    ad_rec_t *ad;
    int16 adbuf[2048];
    uint8 utt_started, in_speech;
    int32 k;
    char  *hyp=0;

    if ((ad = ad_open_dev(cmd_ln_str_r(config, "-adcdev"),(int) cmd_ln_float32_r(config,"-samprate"))) == NULL)
        E_FATAL("Failed to open audio device\n");
    if (ad_start_rec(ad) < 0)
        E_FATAL("Failed to start recording\n");

    if (ps_start_utt(ps) < 0)
        E_FATAL("Failed to start utterance\n");


    utt_started = FALSE;
    E_INFO("Ready....\n");

    for (;;) 
    {

        if ((k = ad_read(ad, adbuf, 2048)) < 0)
            E_FATAL("Failed to read audio\n");
        ps_process_raw(ps, adbuf, k, FALSE, FALSE);
        in_speech = ps_get_in_speech(ps);
        if (in_speech && !utt_started) 
        {
            utt_started = TRUE;
            E_INFO("Listening...\n");
        }
        if (!in_speech && utt_started) 
        {

            ps_end_utt(ps);
            hyp = (char*)ps_get_hyp(ps, NULL );
            if (hyp != NULL) 
            {
///////////////////I am passing hyp to espeak heere ////////////////////
             ad_stop_rec(ad);
             speech(hyp);

                printf("%s\n",hyp);
                fflush(stdout);
            //    sleep_msec(3000);

            }

            if (ps_start_utt(ps) < 0)
                E_FATAL("Failed to start utterance\n");
            utt_started = FALSE;
            E_INFO("Ready....\n");

        }
    }//for
    ad_close(ad);
}

int main(int argc, char *argv[])
{
    initFuncs();

                 config = cmd_ln_init(NULL, ps_args(), TRUE,
                 "-hmm", "/home/m/myrobot3/robot/model_parameters/robot.cd_cont_1000",
                     "-lm","/home/m/myrobot3/robot/etc/robot.lm.bin",
                     "-dict", "/home/m/myrobot3/robot/etc/robot.dic",
                     NULL);

    ps = ps_init(config);
    recognize_from_microphone();

    ps_free(ps);
    cmd_ln_free_r(config);

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
#包括“pocketsphinx.h”
静态ps_解码器_t*ps；
静态cmd_ln_t*config；
静态文件*rawfd；
广告记录*广告；
espeak_位置_类型位置_类型；
espeak_音频_输出；
char*path=NULL；
int BUFLENGHT=1000，选项=0；
作废*用户数据；
字符语音[]={“英语”}；
无符号整数大小，位置=0，结束位置=0，标志=espeakCHARS\u AUTO，*唯一标识符；
t_espeak_callback*SynthCallback；
espeak_参数Parm；
静态void initFuncs（）
{
输出=音频输出播放；
espeak_初始化（输出、带宽、路径、音频输出同步）；
espeak_SetVoiceByName（语音）；
const char*langNativeString=“en”；
埃斯皮克的声音；
memset（&voice，0，sizeof（espeak_voice））；
voice.languages=langNativeString；
voice.name=“美国”；
voice.variant=2；
voice.gender=1；
espeak_SetVoiceByProperties（&voice）；
}
int接收_espeak_事件（短*wav、int numsamples、espeak_事件*EVENT）
{
while（事件->类型！=espeakEVENT\u列表\u终止）{
如果（事件->类型==espeakEVENT\u MSG\u终止）{
/*做点什么*/
ad_启动_记录（ad）；
}
++event；//检查下一个事件。
}
返回0；//继续讲话。
}
静态无效睡眠毫秒（int32毫秒）
{
结构timeval-tmo；
tmo.tv_sec=0；
tmo.tv_usec=ms*1000；
选择（0、NULL、NULL、NULL和tmo）；
}
静态无效语音（char*hyp）
{      
尺寸=strlen（hyp）+1；
espeak_设置同步回调（接收espeak_事件）；
espeak_Synth（hyp、大小、位置、位置类型、结束位置、标志、唯一标识符、用户数据）；
espeak_Synchronize（）；
}
静态无效从话筒识别话筒（）
{
广告记录*广告；
int16 adbuf[2048]；
uint8 utt_在演讲中开始；
int32k；
char*hyp=0；
if（（ad=ad\u open\u dev（cmd\u ln\u str\u r（config，“-adcdev”），（int）cmd\u ln\u float32\u r（config，“-samprate”））==NULL）
E_致命（“无法打开音频设备”）；
if（ad_start_rec（ad）<0）
E_致命（“无法开始录制”）；
如果（ps_开始（ps）<0）
E_FATAL（“无法开始说话”）；
utt_start=FALSE；
E_信息（“准备就绪…”\n）；
对于（；；）
{
如果（（k=ad_read（ad，adbuf，2048））<0）
E_致命（“读取音频失败”）；
ps_过程_原始（ps、adbuf、k、FALSE、FALSE）；
in_speech=ps_get_in_speech（ps）；
如果（在语音中&&！utt_开始）
{
utt_start=TRUE；
E_信息（“监听…\n”）；
}
如果（！in_speech&&utt_已启动）
{
ps_end_utt（ps）；
hyp=（char*）ps\u get\u hyp（ps，NULL）；
如果（hyp！=NULL）
{
///////////////////我正在把hyp传给espeak heere////////////////////
自动停止（ad）；
演讲（hyp）；
printf（“%s\n”，hyp）；
fflush（stdout）；
//睡眠时间（3000毫秒）；
}
如果（ps_开始（ps）<0）
E_FATAL（“无法开始说话”）；
utt_start=FALSE；
E_信息（“准备就绪…”\n）；
}
}//为了
ad_close（ad）；
}
int main（int argc，char*argv[]）
{
initFuncs（）；
config=cmd\u ln\u init（NULL，ps\u args（），TRUE，
“-hmm”，“/home/m/myrobot3/robot/model\u parameters/robot.cd\u cont\u 1000”，
“-lm”、“/home/m/myrobot3/robot/etc/robot.lm.bin”，
“-dict”、“/home/m/myrobot3/robot/etc/robot.dic”，
无效）；
ps=ps_init（配置）；
从_麦克风（）识别_；
无聚苯乙烯（ps）；
cmd_ln_free_r（配置）；
返回0；
}

错误：

致命：“application.cpp”，第163行：无法读取音频

这一行对编译器不敏感<代码>espeak_EVENT_TYPE是一种数据类型。它不是一个可以与

espeakEVENT\u MSG\u TERMINATED

等值进行比较的变量。为了声明变量，语法应为：

espeak_EVENT_TYPE an_event_type {};
if (an_event_type == espeakEVENT_MSG_TERMINATED) {
/* ... */

但是，如果我们这样做，那么我们刚刚创建的变量

事件类型

实际上将不包含任何关于任何真实espeak事件的信息。而且它肯定不会说明任何实际消息是否被终止

从espeak接收真实事件信息 为了获取消息是否终止的信息，程序需要从espeak库中获取类型为

espeak\u EVENT\u type

的变量

---

仔细查看，

espeak_事件类型

用作

espeak_事件

结构的一部分。要接收

espeak_事件

通知，必须编写一个函数，该函数将由espeak库调用。（这称为“回调”函数）。然后通过调用

espeak_SetSynthCallback

向库注册回调函数

从同一标头中，回调函数的原型必须如下所示：

int SynthCallback（短*wav、int numsamples、espeak_事件*events）

wav：是已经产生的语音数据。无效的 表示合成已完成

numsamples：是wav中的条目数。这个数字可能会有所不同， 可能小于>espeak_Initialize中给定的buflength参数所暗示的值，有时可能为零（这并不表示 合成结束）

事件：espeak_事件项的数组，表示单词和 句子事件，以及if和元素的发生 在文本中。事件列表由类型>=0的事件终止

回调返回：0=继续合成，1=中止合成espeak_EVENT_TYPE;

espeak_EVENT_TYPE an_event_type {};
if (an_event_type == espeakEVENT_MSG_TERMINATED) {
/* ... */

int receive_espeak_events(short *wav, int numsamples, espeak_EVENT *event)
{
    while (event->type != espeakEVENT_LIST_TERMINATED) {
        if (event->type == espeakEVENT_MSG_TERMINATED) {
            /* do something */
        }
        ++event; // Examine the next event.
    }
    return 0; // Continue speaking.
}

espeak_SetSynthCallback(receive_espeak_events);