void SpeechSystem::setup()
{
// ewwww
jconf = j_config_load_file_new(const_cast<char*>(jconf_filename.c_str()));
/* 2. create recognition instance according to the jconf */
/* it loads models, setup final parameters, build lexicon
and set up work area for recognition */
recog = j_create_instance_from_jconf(jconf);
if (recog == NULL)
{
fprintf(stderr, "Error in startup\n");
return;
}
/*********************/
/* Register callback */
/*********************/
/* register result callback functions */
callback_add(recog, CALLBACK_EVENT_SPEECH_READY, recready, this);
callback_add(recog, CALLBACK_EVENT_SPEECH_START, recstart, this);
callback_add(recog, CALLBACK_RESULT, recdone, this);
/**************************/
/* Initialize audio input */
/**************************/
/* initialize audio input device */
/* ad-in thread starts at this time for microphone */
if (j_adin_init(recog) == FALSE) { /* error */
return;
}
//#ifdef JULIUS_DEBUG
/* output system information to log */
j_recog_info(recog);
//#endif
/***********************************/
/* Open input stream and recognize */
/***********************************/
/* raw speech input (microphone etc.) */
switch(j_open_stream(recog, NULL)) {
case 0: /* succeeded */
break;
case -1: /* error */
fprintf(stderr, "error in input stream\n");
return;
case -2: /* end of recognition process */
fprintf(stderr, "failed to begin input stream\n");
return;
}
startThread(true, false); // blocking, verbose
}
bool SpRecog::loadConfigFile(Application *app)
{
char conf_file_name[] = "julius.conf";
jconf = j_config_load_file_new(conf_file_name);
if (jconf == NULL) {
app->tell("error in j_config_load_file_new");
fprintf(stderr, "error in j_config_load_file_new\n");
return false;
}
recog = j_create_instance_from_jconf(jconf);
if (recog == NULL) {
app->tell("error in j_create_instance_from_jconf");
return false;
}
return true;
}
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;
}
//========================
// Create engine instance
//========================
bool cJulius::createEngine( void )
{
#ifdef APP_ADIN
ADIn *a;
#endif
if (!m_jconf) return false;
if (m_recog) return false;
#ifdef APP_ADIN
if (m_appsource != 0) {
switch(m_appsource) {
case 1: // buffer input, batch
m_recog->jconf->input.type = INPUT_WAVEFORM;
m_recog->jconf->input.speech_input = SP_RAWFILE;
m_recog->jconf->decodeopt.realtime_flag = FALSE;
break;
case 2: // buffer input, incremental
m_recog->jconf->input.type = INPUT_WAVEFORM;
m_recog->jconf->input.speech_input = SP_RAWFILE;
m_recog->jconf->decodeopt.realtime_flag = TRUE;
break;
}
}
#endif
// Create engine instance
m_recog = j_create_instance_from_jconf(m_jconf);
if (m_recog == NULL) {
return false;
}
// Register callbacks
callback_add(m_recog, CALLBACK_EVENT_PROCESS_ONLINE, ::callback_engine_active, this);
callback_add(m_recog, CALLBACK_EVENT_PROCESS_OFFLINE, ::callback_engine_inactive, this);
callback_add(m_recog, CALLBACK_EVENT_SPEECH_READY, ::callback_audio_ready, this);
callback_add(m_recog, CALLBACK_EVENT_SPEECH_START, ::callback_audio_begin, this);
callback_add(m_recog, CALLBACK_EVENT_SPEECH_STOP, ::callback_audio_end, this);
callback_add(m_recog, CALLBACK_EVENT_RECOGNITION_BEGIN, ::callback_recog_begin, this);
callback_add(m_recog, CALLBACK_EVENT_RECOGNITION_END, ::callback_recog_end, this);
callback_add(m_recog, CALLBACK_EVENT_PASS1_FRAME, ::callback_recog_frame, this);
callback_add(m_recog, CALLBACK_EVENT_PAUSE, ::callback_engine_pause, this);
callback_add(m_recog, CALLBACK_EVENT_RESUME, ::callback_engine_resume, this);
callback_add(m_recog, CALLBACK_RESULT, ::callback_result_final, this);
callback_add(m_recog, CALLBACK_PAUSE_FUNCTION, ::callback_wait_for_resume, this);
#ifdef APP_ADIN
// Initialize application side audio input
if (m_appsource != 0) {
a = m_recog->adin;
switch(m_appsource) {
case 1: // buffer input, batch
a->ad_standby = NULL;
a->ad_begin = NULL;
a->ad_end = NULL;
a->ad_resume = NULL;
a->ad_pause = NULL;
a->ad_terminate = NULL;
a->ad_read = callback_adin_fetch_input;
a->ad_input_name = NULL;
a->silence_cut_default = FALSE;
a->enable_thread = FALSE;
break;
case 2: // buffer input, incremental
a->ad_standby = NULL;
a->ad_begin = NULL;
a->ad_end = NULL;
a->ad_resume = NULL;
a->ad_pause = NULL;
a->ad_terminate = NULL;
a->ad_read = callback_adin_fetch_input;
a->ad_input_name = NULL;
a->silence_cut_default = FALSE;
a->enable_thread = FALSE;
break;
}
a->ds = NULL;
a->down_sample = FALSE;
if (adin_standby(a, m_recog->jconf->input.sfreq, NULL) == FALSE) return false;
if (adin_setup_param(a, m_recog->jconf) == FALSE) return false;
a->input_side_segment = FALSE;
} else {
// Let JuliusLib get audio input
if (! j_adin_init( m_recog ) ) return false;
}
#else
if (! j_adin_init( m_recog ) ) return false;
#endif
return true;
}
xreturn::r<bool> JuliusPlus::JuliusFileStart()
{
assert(this->recogFile == NULL);
assert(this->jconfFile == NULL);
const char* argv[]={
"juliusplus"
,"-C"
,"testfile.jconf"
};
int argc = sizeof(argv)/sizeof(argv[0]);
//julius は C関数だから、const外して char** にするしかない。
this->jconfFile = 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->jconfFile == 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->recogFile = j_create_instance_from_jconf(this->jconfFile);
if (this->recogFile == NULL)
{
return xreturn::error("Error in startup(j_create_instance_from_jconf)\n");
}
struct _ref{
static void output_result(Recog *recog, void *_this)
{
((JuliusPlus*)_this)->OnOutputResultFile(recog);
}
};
callback_add(this->recogFile, CALLBACK_RESULT, _ref::output_result, this);
// Initialize audio input
if (j_adin_init(this->recogFile) == FALSE)
{
return xreturn::error("Error in startup(j_adin_init)\n");
}
//以上、準備だけしておいて、
//認識ルーチンは、後から呼びます。
/*
int ret = j_open_stream(recogFile, "nano.wav");
if(ret < 0)
{
return xreturn::error("Error in startup(j_open_stream)\n");
}
j_recognize_stream(recogFile);
ret = j_open_stream(recogFile, "nano.wav");
if(ret < 0)
{
return xreturn::error("Error in startup(j_open_stream)\n");
}
j_recognize_stream(recogFile);
*/
return true;
}
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);
}
