Julius 4.2
libjulius/src/callback.c
説明を見る。
00001 
00036 #include <julius/julius.h>
00037 
00052 void
00053 callback_init(Recog *recog)
00054 {
00055   int i;
00056   for(i=0;i<SIZEOF_CALLBACK_ID;i++) recog->callback_function_num[i] = 0;
00057   recog->callback_num = 0;
00058 }
00059 
00076 static int
00077 callback_add_core(Recog *recog, int code, void (*func)(), void *data)
00078 {
00079   int i;
00080   int num;
00081   int newid;
00082 
00083   num = recog->callback_function_num[code];
00084 
00085   if (num >= MAX_CALLBACK_HOOK) {
00086     jlog("ERROR: callback_add: failed to add callback for slot %d\n", code);
00087     jlog("ERROR: callback_add: maximum number of callback for a slot is limited to %d\n", MAX_CALLBACK_HOOK);
00088     jlog("ERROR: callback_add: please increase the value of MAX_CALLBACK_HOOK\n");
00089     return -1;
00090   }
00091 
00092   for(i=0;i<num;i++) {
00093     if (recog->callback_function[code][i] == func && recog->callback_user_data[code][i] == data) {
00094       jlog("WARNING: callback_add: the same callback already registered at slot %d\n", code);
00095       return -1;
00096     }
00097   }
00098   recog->callback_function[code][num] = func;
00099   recog->callback_user_data[code][num] = data;
00100   recog->callback_function_num[code]++;
00101 
00102   newid = recog->callback_num;
00103   if (newid >= MAX_CALLBACK_HOOK * SIZEOF_CALLBACK_ID) {
00104     jlog("ERROR: callback_add: callback registration count reached maximum limit (%d)!\n", MAX_CALLBACK_HOOK * SIZEOF_CALLBACK_ID);
00105     return -1;
00106   }
00107   recog->callback_list_code[newid] = code;
00108   recog->callback_list_loc[newid] = num;
00109   recog->callback_num++;
00110 
00111   return newid;
00112 }
00113 
00134 int
00135 callback_add(Recog *recog, int code, void (*func)(Recog *recog, void *data), void *data)
00136 {
00137   return(callback_add_core(recog, code, func, data));
00138 }
00139 
00160 int
00161 callback_add_adin(Recog *recog, int code, void (*func)(Recog *recog, SP16 *buf, int len, void *data), void *data)
00162 {
00163   return(callback_add_core(recog, code, func, data));
00164 }
00165 
00166 static void
00167 c_out(const char *s, int flag)
00168 {
00169   if (flag == 0) {
00170     jlog("DEBUG: (%s)\n", s);
00171   } else {
00172     jlog("DEBUG: %s\n", s);
00173   }
00174 }
00175 
00176 static void
00177 callback_debug_stdout(int code, Recog *recog)
00178 {
00179   int f = recog->callback_function_num[code];
00180   switch(code) {
00181     //case CALLBACK_POLL: c_out("CALLBACK_POLL", f); break;
00182   case CALLBACK_EVENT_PROCESS_ONLINE: c_out("CALLBACK_EVENT_PROCESS_ONLINE", f); break;
00183   case CALLBACK_EVENT_PROCESS_OFFLINE: c_out("CALLBACK_EVENT_PROCESS_OFFLINE", f); break;
00184   case CALLBACK_EVENT_STREAM_BEGIN: c_out("CALLBACK_EVENT_STREAM_BEGIN", f); break;
00185   case CALLBACK_EVENT_STREAM_END: c_out("CALLBACK_EVENT_STREAM_END", f); break;
00186   case CALLBACK_EVENT_SPEECH_READY: c_out("CALLBACK_EVENT_SPEECH_READY", f); break;
00187   case CALLBACK_EVENT_SPEECH_START: c_out("CALLBACK_EVENT_SPEECH_START", f); break;
00188   case CALLBACK_EVENT_SPEECH_STOP: c_out("CALLBACK_EVENT_SPEECH_STOP", f); break;
00189   case CALLBACK_EVENT_RECOGNITION_BEGIN: c_out("CALLBACK_EVENT_RECOGNITION_BEGIN", f); break;
00190   case CALLBACK_EVENT_RECOGNITION_END: c_out("CALLBACK_EVENT_RECOGNITION_END", f); break;
00191   case CALLBACK_EVENT_SEGMENT_BEGIN: c_out("CALLBACK_EVENT_SEGMENT_BEGIN", f); break;
00192   case CALLBACK_EVENT_SEGMENT_END: c_out("CALLBACK_EVENT_SEGMENT_END", f); break;
00193   case CALLBACK_EVENT_PASS1_BEGIN: c_out("CALLBACK_EVENT_PASS1_BEGIN", f); break;
00194     //case CALLBACK_EVENT_PASS1_FRAME: c_out("CALLBACK_EVENT_PASS1_FRAME", f); break;
00195   case CALLBACK_EVENT_PASS1_END: c_out("CALLBACK_EVENT_PASS1_END", f); break;
00196     //case CALLBACK_RESULT_PASS1_INTERIM: c_out("CALLBACK_RESULT_PASS1_INTERIM", f); break;
00197   case CALLBACK_RESULT_PASS1: c_out("CALLBACK_RESULT_PASS1", f); break;
00198   case CALLBACK_RESULT_PASS1_GRAPH: c_out("CALLBACK_RESULT_PASS1_GRAPH", f); break;
00199   case CALLBACK_STATUS_PARAM: c_out("CALLBACK_STATUS_PARAM", f); break;
00200   case CALLBACK_EVENT_PASS2_BEGIN: c_out("CALLBACK_EVENT_PASS2_BEGIN", f); break;
00201   case CALLBACK_EVENT_PASS2_END: c_out("CALLBACK_EVENT_PASS2_END", f); break;
00202   case CALLBACK_RESULT: c_out("CALLBACK_RESULT", f); break;
00203   case CALLBACK_RESULT_GMM: c_out("CALLBACK_RESULT_GMM", f); break;
00204   case CALLBACK_RESULT_GRAPH: c_out("CALLBACK_RESULT_GRAPH", f); break;
00205   case CALLBACK_RESULT_CONFNET: c_out("CALLBACK_RESULT_CONFNET", f); break;
00206     //case CALLBACK_ADIN_CAPTURED: c_out("CALLBACK_ADIN_CAPTURED", f); break;
00207     //case CALLBACK_ADIN_TRIGGERED: c_out("CALLBACK_ADIN_TRIGGERED", f); break;
00208   case CALLBACK_EVENT_PAUSE: c_out("CALLBACK_EVENT_PAUSE", f); break;
00209   case CALLBACK_EVENT_RESUME: c_out("CALLBACK_EVENT_RESUME", f); break;
00210   case CALLBACK_PAUSE_FUNCTION: c_out("CALLBACK_PAUSE_FUNCTION", f); break;
00211   case CALLBACK_DEBUG_PASS2_POP: c_out("CALLBACK_DEBUG_PASS2_POP", f); break;
00212   case CALLBACK_DEBUG_PASS2_PUSH: c_out("CALLBACK_DEBUG_PASS2_PUSH", f); break;
00213     //case CALLBACK_RESULT_PASS1_DETERMINED: c_out("CALLBACK_RESULT_PASS1_DETERMINED", f); break;
00214   }
00215 }
00216 
00232 void
00233 callback_exec(int code, Recog *recog)
00234 {
00235   int i;
00236 
00237   if (code < 0 || code >= SIZEOF_CALLBACK_ID) {
00238     jlog("ERROR: callback_exec: failed to exec callback: invalid code number: %d\n", code);
00239     return;
00240   }
00241   if (callback_debug_flag) callback_debug_stdout(code, recog);
00242   for(i=0;i<recog->callback_function_num[code];i++) {
00243     (*(recog->callback_function[code][i]))(recog, recog->callback_user_data[code][i]);
00244   }
00245 }
00246 
00264 void
00265 callback_exec_adin(int code, Recog *recog, SP16 *buf, int len) 
00266 {
00267   int i;
00268 
00269   if (code < 0 || code >= SIZEOF_CALLBACK_ID) {
00270     jlog("ERROR: callback_exec_adin: failed to exec callback: invalid code number: %d\n", code);
00271     return;
00272   }
00273   if (callback_debug_flag) callback_debug_stdout(code, recog);
00274   for(i=0;i<recog->callback_function_num[code];i++) {
00275     (*(recog->callback_function[code][i]))(recog, buf, len, recog->callback_user_data[code][i]);
00276   }
00277 }
00278 
00297 boolean
00298 callback_exist(Recog *recog, int code)
00299 {
00300   if (recog->callback_function_num[code] == 0) return FALSE;
00301   return TRUE;
00302 }
00303 
00322 boolean
00323 callback_delete(Recog *recog, int id)
00324 {
00325   int code;
00326   int loc;
00327   int i;
00328 
00329   if (id >= recog->callback_num || id < 0) {
00330     jlog("ERROR: callback_delete: callback id #%d not exist!\n", id);
00331     return FALSE;
00332   }
00333 
00334   code = recog->callback_list_code[id];
00335   loc  = recog->callback_list_loc[id];
00336 
00337   if (code == -1) {
00338     jlog("WARNING: callback_delete: callback #%d already deleted\n", id);
00339     return TRUE;
00340   }
00341 
00342   for(i=loc;i<recog->callback_function_num[code]-1;i++) {
00343     recog->callback_function[code][i] = recog->callback_function[code][i+1];
00344     recog->callback_function[code][i] = recog->callback_function[code][i+1];
00345     recog->callback_user_data[code][i] = recog->callback_user_data[code][i+1];
00346   }
00347   recog->callback_function_num[code]--;
00348   recog->callback_list_code[id] = -1;
00349   recog->callback_list_loc[id] = -1;
00350 
00351   jlog("STAT: callback #%d deleted\n", id);
00352   return TRUE;
00353 }
00354 
00355 /* end of file */