bool SpRecog::start(Application *app)
{
if (j_adin_init(this->recog) == FALSE) {
app->tell("error in j_adin_init");
return false;
}
j_recog_info(this->recog); /* output system information to log */
switch(j_open_stream(this->recog, NULL)) {
case 0:
app->tell("ok j_open_stream");
break;
case -1:
app->tell("error in input stream");
return false;
case -2:
app->tell("error in beginning input");
return false;
}
fflush(this->srm_log_fp);
int ret = j_recognize_stream(this->recog);
if (ret == -1) {
app->tell("error j_recognize_stream");
return false;
}
return true;
}
// main function for the engine thread
unsigned __stdcall recogThreadMain( void *param )
{
int ret;
Recog *recog = (Recog *)param;
ret = j_recognize_stream(recog);
_endthreadex(ret);
return(ret);
}
void SpeechSystem::threadedFunction()
{
/**********************/
/* Recognization Loop */
/**********************/
/* enter main loop to recognize the input stream */
/* finish after whole input has been processed and input reaches end */
j_recognize_stream(recog);
if (verbose) printf("SpeechSystem::threadedFunction()\n");
}
//呼びかけがあれば、waveで保存し、もう一つのjuliusインスタンスで再チェックする.
bool JuliusPlus::checkDictation(Recog *recog,const OncSentence* sentence) const
{
if (!this->UseDictationFilter)
{//チェックをしないのなら常に true 正解を返す.
std::cout << "#checkDictation: no-check" << std::endl;
return true;
}
auto it3 = sentence->nodes.begin();
if (it3 == sentence->nodes.end() )
{
std::cout << "#checkDictation: no-word" << std::endl;
return false;
}
if (! checkYobikake( (*it3)->wordnode->yomiPress ) )
{
std::cout << "#checkDictation: gomi word" << std::endl;
return false;
}
const std::string waveFilename = "__temp__DictationCheck.wav";
//認識した結果の最初の呼びかけの部分を保存.
WaveCutter(recog,sentence->all_frame,(*it3)->begin_frame-1,(*it3)->end_frame, waveFilename );
//もう一つの julius インスタンスで wave ファイルからの認識をやります.
//これで過剰マッチを完全に叩き落とします。
//結果は、this->DictationCheckString に保存されます。
//char*にしているのはjuliusがC関数なので constがないため・・・
int ret = j_open_stream(this->recogFile,(char*) waveFilename.c_str() );
if(ret < 0)
{
std::cout << "#checkDictation: j_open error" << std::endl;
return false;
}
j_recognize_stream(this->recogFile);
std::cout << "#" << this->DictationCheckString << std::endl;
//内容のチェック
if (! checkYobikake( this->DictationCheckString ) )
{
return false;
}
return true;
}
void cTumkwsjSink::juliusDecoderThread()
{
bool term;
smileMutexLock(terminatedMtx);
term = terminated;
smileMutexUnlock(terminatedMtx);
/* enter recongnition loop */
int ret = j_open_stream(recog, NULL);
switch(ret) {
case 0: /* succeeded */
break;
case -1: /* error */
/* go on to next input */
//continue;
case -2: /* end of recognition process */
if (jconf->input.speech_input == SP_RAWFILE) {
// fprintf(stderr, "%d files processed\n", file_counter);
} else if (jconf->input.speech_input == SP_STDIN) {
fprintf(stderr, "reached end of input on stdin\n");
} else {
fprintf(stderr, "failed to begin input stream\n");
}
return;
}
/*
if (outfile_enabled) {
outfile_set_fname(j_get_current_filename());
}
*/
// TODO: terminate mechanism!!
/* start recognizing the stream */
ret = j_recognize_stream(recog);
}
int main(int argc, char* argv[])
{
// Jconf: configuration parameters
// load configurations from command arguments
Jconf *jconf = j_config_load_args_new(argc, argv);
if (jconf == NULL) {
std::cout << "Error @ j_config_load_args_new" << std::endl;
return -1;
}
// Recog: Top level instance for the whole recognition process
// create recognition instance according to the jconf
Recog *recog = j_create_instance_from_jconf(jconf);
if (recog == NULL) {
std::cout << "Error @ j_create_instance_from_jconf" << std::endl;
return -1;
}
// Regster callback
callback_add(recog, CALLBACK_EVENT_SPEECH_READY, [](Recog *recog, void*) {
std::cout << "<<< PLEASE SPEAK! >>>" << std::endl;
}, NULL);
callback_add(recog, CALLBACK_EVENT_SPEECH_START, [](Recog *recog, void*) {
std::cout << "...SPEECH START..." << std::endl;
}, NULL);
callback_add(recog, CALLBACK_RESULT, [](Recog *recog, void*) {
for (const RecogProcess *r = recog->process_list; r; r = r->next) {
WORD_INFO *winfo = r->lm->winfo;
for (int n = 0; n < r->result.sentnum; ++n) {
Sentence *s = &(r->result.sent[n]);
WORD_ID *seq = s->word;
int seqnum = s->word_num;
for (int i = 0; i < seqnum; ++i) {
std::cout << winfo->woutput[seq[i]];
}
}
}
}, NULL);
// Initialize audio input
if (j_adin_init(recog) == FALSE) {
return -1;
}
// output system information to log
j_recog_info(recog);
// Open input stream and recognize
switch (j_open_stream(recog, NULL)) {
case 0: break; // success
case -1: std::cout << "Error in input stream" << std::endl; return -1;
case -2: std::cout << "Failed to begin input stream" << std::endl; return -1;
}
// Recognition loop
int ret = j_recognize_stream(recog);
if (ret == -1) return -1;
// exit
j_close_stream(recog);
j_recog_free(recog);
return 0;
}
xreturn::r<bool> JuliusPlus::JuliusStart()
{
assert(this->recog == NULL);
assert(this->jconf == NULL);
assert(this->Thread == NULL);
const char* argv[]={
"juliusplus"
,"-C"
,"testmic.jconf"
};
int argc = sizeof(argv)/sizeof(argv[0]);
int ret;
//julusはC関数なので、const外して char** にするしかない・・・
this->jconf = j_config_load_args_new(argc, (char**)argv);
/* else, you can load configurations from a jconf file */
//jconf = j_config_load_file_new(jconf_filename);
if (this->jconf == NULL)
{
return xreturn::error("Try `-help' for more information.\n");
}
/* 2. create recognition instance according to the jconf */
/* it loads models, setup final parameters, build lexicon
and set up work area for recognition */
this->recog = j_create_instance_from_jconf(this->jconf);
if (this->recog == NULL)
{
return xreturn::error("Error in startup(j_create_instance_from_jconf)\n");
}
struct _ref{
static void status_recready(Recog *recog, void *_this)
{
((JuliusPlus*)_this)->OnStatusRecready(recog);
}
static void status_recstart(Recog *recog, void *_this)
{
((JuliusPlus*)_this)->OnStatusRecstart(recog);
}
static void output_result(Recog *recog, void *_this)
{
((JuliusPlus*)_this)->OnOutputResult(recog);
}
static void record_adin_trigger(Recog *recog, SP16 *speech, int samplenum, void *_this)
{
((JuliusPlus*)_this)->OnRecordAdinTrigger(recog,speech,samplenum);
}
};
callback_add(this->recog, CALLBACK_EVENT_SPEECH_READY, _ref::status_recready, this);
callback_add(this->recog, CALLBACK_EVENT_SPEECH_START, _ref::status_recstart, this);
callback_add(this->recog, CALLBACK_RESULT, _ref::output_result, this);
callback_add_adin(this->recog, CALLBACK_ADIN_TRIGGERED, _ref::record_adin_trigger, this);
// Initialize audio input
if (j_adin_init(this->recog) == FALSE)
{
return xreturn::error("Error in startup(j_adin_init)\n");
}
//output system information to log
//j_recog_info(this->recog);
ret = j_open_stream(recog, NULL);
if(ret < 0)
{
return xreturn::error("Error in startup(j_open_stream)\n");
}
this->Thread = new boost::thread( [&]()
{
j_recognize_stream(recog);
} );
return true;
}
/* Julius_Thread::run: main loop */
void Julius_Thread::run()
{
char *tmp;
char buff[MMDAGENT_MAXBUFLEN];
FILE *fp;
if(m_jconf != NULL || m_recog != NULL || m_mmdagent == NULL || m_thread < 0 || m_languageModel == 0 || m_dictionary == 0 || m_acousticModel == 0 || m_triphoneList == 0 || m_configFile == 0)
return;
/* set latency */
sprintf(buff, "PA_MIN_LATENCY_MSEC=%d", JULIUSTHREAD_LATENCY);
putenv(buff);
sprintf(buff, "LATENCY_MSEC=%d", JULIUSTHREAD_LATENCY);
putenv(buff);
/* turn off log */
jlog_set_output(NULL);
/* load models */
tmp = MMDAgent_pathdup(m_languageModel);
sprintf(buff, "-d \"%s\"", tmp);
free(tmp);
m_jconf = j_config_load_string_new(buff);
if (m_jconf == NULL) {
return;
}
tmp = MMDAgent_pathdup(m_dictionary);
sprintf(buff, "-v \"%s\"", tmp);
free(tmp);
if(j_config_load_string(m_jconf, buff) < 0) {
return;
}
tmp = MMDAgent_pathdup(m_acousticModel);
sprintf(buff, "-h \"%s\"", tmp);
free(tmp);
if(j_config_load_string(m_jconf, buff) < 0) {
return;
}
tmp = MMDAgent_pathdup(m_triphoneList);
sprintf(buff, "-hlist \"%s\"", tmp);
free(tmp);
if(j_config_load_string(m_jconf, buff) < 0) {
return;
}
/* load config file */
tmp = MMDAgent_pathdup(m_configFile);
if(j_config_load_file(m_jconf, tmp) < 0) {
free(tmp);
return;
}
free(tmp);
/* load user dictionary */
fp = MMDAgent_fopen(m_userDictionary, "r");
if(fp != NULL) {
fclose(fp);
tmp = MMDAgent_pathdup(m_userDictionary);
j_add_dict(m_jconf->lm_root, tmp);
free(tmp);
}
/* create instance */
m_recog = j_create_instance_from_jconf(m_jconf);
if (m_recog == NULL) {
return;
}
/* register callback functions */
callback_add(m_recog, CALLBACK_EVENT_RECOGNITION_BEGIN, callbackRecogBegin, this);
callback_add(m_recog, CALLBACK_RESULT, callbackRecogResult, this);
if (!j_adin_init(m_recog)) {
return;
}
if (j_open_stream(m_recog, NULL) != 0) {
return;
}
/* setup logger */
m_logger.setup(m_recog);
/* start logger */
m_logger.setActiveFlag(true);
/* start recognize */
j_recognize_stream(m_recog);
}
