static PyObject *
pyhobdcalc_octdivoct(PyObject *self, PyObject *args) {
/** Python function wrapper for dividing two octal integer string and return the result as an float string. **/
char *octdivstr1 ; /** variable for converting an python string into an C string. **/
char *octdivstr2 ; /** variable for converting an python string into an C string. **/
long double retval ; /** Variable for result computing. **/
_Bool is_1_negativ=false ; /** Boolean value to check if the given first argument is negativ. **/
_Bool is_2_negativ=false ; /** Boolean value to check if the given second argument is negativ. **/
_Bool is_result_negativ=false ; /** Boolean value to check if the result should be negativ. **/
_Bool change_argument_value1=false ; /** Variable to check if the octal identifier "0" is present
* in the first given argument string. **/
_Bool change_argument_value2=false ; /** Variable to check if the octal identifier "0" is present
* in the second given argument string. **/
if (!PyArg_ParseTuple(args, "ss", &octdivstr1,&octdivstr2)) {
/** Failing to convert the given python string into an C string. **/
return NULL;
}
if (octdivstr1[0] == '-' && octdivstr1[1] == '0') {
/** The first argument octal string is negativ and start with the octal identifier prefix "0". **/
octdivstr1[1]='-' ; /** We set the negativ sign to index 1. **/
octdivstr1++ ; /** We increment the pointer to point on the negativ sign
* so that we get it at the string start. **/
is_1_negativ=true ; /** We set the negativ boolean value on true. **/
change_argument_value1=true ; /** Octal identifier detected with negativ sign. **/
}
else if (octdivstr1[0] == '0') {
/** The first argument octal string start with the octal identifier prefix "0". **/
octdivstr1++ ; /** We increment the pointer to point on the data begin
* to ignore the octal identifier prefix "0". **/
change_argument_value1=true ; /** Octal identifier detected without negativ sign. **/
}
else if (octdivstr1[0] == '-') {
/** The first argument octal string is negativ. **/
is_1_negativ=true ; /** We set the negativ boolean value on true. **/
}
if (octdivstr2[0] == '-' && octdivstr2[1] == '0') {
/** The second argument octal string is negativ and start with the octal identifier prefix "0". **/
octdivstr2[1]='-' ; /** We set the negativ sign to index 1. **/
octdivstr2++ ; /** We increment the pointer to point on the negativ sign
* so that we get it at the string start. **/
is_2_negativ=true ; /** We set the negativ boolean value on true. **/
change_argument_value2=true ; /** Octal identifier detected with negativ sign. **/
}
else if (octdivstr2[0] == '0') {
/** The second argument octal string start with the octal identifier prefix "0". **/
octdivstr2++ ; /** We increment the pointer to point on the data begin
* to ignore the octal identifier prefix "0". **/
change_argument_value2=true ; /** Octal identifier detected without negativ sign. **/
}
else if (octdivstr2[0] == '-') {
/** The second argument octal string is negativ. **/
is_2_negativ=true ; /** We set the negativ boolean value on true. **/
}
if (strlen(octdivstr1) > 24 && ! is_1_negativ ) {
/** The string is too length for the operation peforming.
* So we raise an OverflowError exception an abort the division function. **/
PyErr_SetString(PyExc_OverflowError,"Maximal octal string argument 1 length: 21 characters.") ;
return NULL ;
}
else if (strlen(octdivstr1) > 25 && is_1_negativ ) {
/** The string is too length for the operation peforming.
* So we raise an OverflowError exception an abort the division function. **/
PyErr_SetString(PyExc_OverflowError,"Maximal octal string argument 1 length: 21 characters.") ;
return NULL ;
}
if (strlen(octdivstr2) > 24 && ! is_2_negativ ) {
/** The string is too length for the operation peforming.
* So we raise an OverflowError exception an abort the division function. **/
PyErr_SetString(PyExc_OverflowError,"Maximal octal string argument 2 length: 21 characters.") ;
return NULL ;
}
else if (strlen(octdivstr2) > 25 && is_2_negativ ) {
/** The string is too length for the operation peforming.
* So we raise an OverflowError exception an abort the division function. **/
PyErr_SetString(PyExc_OverflowError,"Maximal octal string argument 2 length: 12 characters.") ;
return NULL ;
}
if (! is_string_as_base_an_valid_entry(octdivstr1,8) ) {
/** The given string is not an valid octal string.
* So we raise an ValueError exception and abort the division function. **/
PyErr_SetString(PyExc_ValueError,"Argument 1 must be an octal string: in form [-][0][0-7].") ;
return NULL ;
}
if (! is_string_as_base_an_valid_entry(octdivstr2,8) ) {
/** The given string is not an valid octal string.
* So we raise an ValueError exception and abort the division function. **/
PyErr_SetString(PyExc_ValueError,"Argument 2 must be an octal string: in form [-][0][0-7].") ;
return NULL ;
}
if ( is_string_float(octdivstr1) ) {
/** The given string is not an valid octal integer string,
* but an octal float string.
* So we raise an ValueError exception and abort the division function. **/
PyErr_SetString(PyExc_ValueError,"Argument 1 must be an octal integer string: in form [-][0][0-7].") ;
return NULL ;
}
if ( is_string_float(octdivstr2) ) {
/** The given string is not an valid octal integer string,
* but an octal float string.
* So we raise an ValueError exception and abort the division function. **/
PyErr_SetString(PyExc_ValueError,"Argument 2 must be an octal integer string: in form [-][0][0-7].") ;
return NULL ;
}
/** We check if the result should be negativ or positiv. In relationship of the signs and values from the arguments. **/
if ( ( octtoint(octdivstr1) > octtoint(octdivstr2) ) && (! is_1_negativ) && ( is_2_negativ) ) {
is_result_negativ=true ;
}
else if ( ( octtoint(octdivstr1) < octtoint(octdivstr2) ) && is_1_negativ && (! is_2_negativ) ) {
is_result_negativ=true ;
}
else if ( is_1_negativ && is_2_negativ ) {
is_result_negativ=false ;
}
else if ( (! is_1_negativ) && (! is_2_negativ) ) {
is_result_negativ=false ;
}
retval=octdivoct(octdivstr1,octdivstr2) ; /** We perform the division and store the result in retval. **/
if (change_argument_value1 && is_1_negativ) {
/** We reset the pointer of the first given argument for giving it correctly back.
* In case the user want to reuse the variable given as argument. **/
octdivstr1-- ;
octdivstr1[1]='0' ;
}
else if (change_argument_value1 && (! is_1_negativ) ) {
/** We reset the pointer of the first given argument for giving it correctly back.
* In case the user want to reuse the variable given as argument. **/
octdivstr1-- ;
}
if (change_argument_value2 && is_2_negativ) {
/** We reset the pointer of the second given argument for giving it correctly back.
* In case the user want to reuse the variable given as argument. **/
octdivstr2-- ;
octdivstr2[1]='0' ;
}
else if (change_argument_value2 && (! is_2_negativ) ) {
/** We reset the pointer of the second given argument for giving it correctly back.
* In case the user want to reuse the variable given as argument. **/
octdivstr2-- ;
}
char string_to_return[128] ; /** We need an string to return it **/
memset(string_to_return,'\0',128) ; /** Setting all bits on '\0'. **/
sprintf(string_to_return,"%.15Lf",retval) ; /** Copy the result value into an string. **/
strip_zero(string_to_return) ; /** Stripping the uneeded zeros. **/
if ( (string_to_return[0] == '-') && ! is_result_negativ ) {
/** The division result is positiv and the result string is negativ.
* This come from an value overflow.
* So we raise an Overflow exception an abort the operation function. **/
PyErr_SetString(PyExc_OverflowError,"Value overflow: arguments quotient value to great for operation.") ;
return NULL ;
}
else if ( (! string_to_return[0] == '-') && is_result_negativ ) {
/** The division result is negativ and the result string is positiv.
* This come from an value overflow.
* So we raise an OverflowError exception an abort the operation function. **/
PyErr_SetString(PyExc_OverflowError,"Value overflow: arguments quotient value to great for operation.") ;
return NULL ;
}
/** We return the operation result as an string because we cannot return an long double to python. **/
return Py_BuildValue("s",string_to_return); /** Convert an C string into an python string and return it. **/
}
/**
* <EN>
* @brief Main A/D-in and sound detection function
*
* This function read inputs from device and do sound detection
* (both up trigger and down trigger) until end of device.
*
* In threaded mode, this function will detach and loop forever as
* ad-in thread, (adin_thread_create()) storing triggered samples in
* speech[], and telling the status to another process thread via @a
* transfer_online in work area. The process thread, called from
* adin_go(), polls the length of speech[] and transfer_online in work area
* and process them if new samples has been stored.
*
* In non-threaded mode, this function will be called directly from
* adin_go(), and triggered samples are immediately processed within here.
*
* Threaded mode should be used for "live" input such as microphone input
* where input is infinite and capture delay is severe. For file input,
* adinnet input and other "buffered" input, non-threaded mode will be used.
*
* Argument "ad_process()" should be a function to process the triggered
* input samples. On real-time recognition, a frame-synchronous search
* function for the first pass will be specified by the caller. The current
* input will be segmented if it returns 1, and will be terminated as error
* if it returns -1.
*
* When the argument "ad_check()" specified, it will be called periodically.
* When it returns less than 0, this function will be terminated.
*
* </EN>
* <JA>
* @brief 音声入力と音検出を行うメイン関数
*
* ここでは音声入力の取り込み，音区間の開始・終了の検出を行います.
*
* スレッドモード時，この関数は独立したAD-inスレッドとしてデタッチされます.
* (adin_thread_create()), 音入力を検知するとこの関数はワークエリア内の
* speech[] にトリガしたサンプルを記録し，かつ transfer_online を TRUE に
* セットします. Julius のメイン処理スレッド (adin_go()) は
* adin_thread_process() に移行し，そこで transfer_online 時に speech[] を
* 参照しながら認識処理を行います.
*
* 非スレッドモード時は，メイン処理関数 adin_go() は直接この関数を呼び，
* 認識処理はこの内部で直接行われます.
*
* スレッドモードはマイク入力など，入力が無限で処理の遅延がデータの
* 取りこぼしを招くような live input で用いられます. 一方，ファイル入力
* やadinnet 入力のような buffered input では非スレッドモードが用いられます.
*
* 引数の ad_process は，取り込んだサンプルに対して処理を行う関数を
* 指定します. リアルタイム認識を行う場合は，ここに第1パスの認識処理を
* 行う関数が指定されます. 返り値が 1 であれば，入力をここで区切ります.
* -1 であればエラー終了します.
*
* 引数の ad_check は一定処理ごとに繰り返し呼ばれる関数を指定します. この
* 関数の返り値が 0 以下だった場合，入力を即時中断して関数を終了します.
* </JA>
*
* @param ad_process [in] function to process triggerted input.
* @param ad_check [in] function to be called periodically.
* @param recog [in] engine instance
*
* @return 2 when input termination requested by ad_process(), 1 when
* if detect end of an input segment (down trigger detected after up
* trigger), 0 when reached end of input device, -1 on error, -2 when
* input termination requested by ad_check().
*
* @callergraph
* @callgraph
*
*/
static int
adin_cut(int (*ad_process)(SP16 *, int, Recog *), int (*ad_check)(Recog *), Recog *recog)
{
ADIn *a;
int i;
int ad_process_ret;
int imax, len, cnt;
int wstep;
int end_status = 0; /* return value */
boolean transfer_online_local; /* local repository of transfer_online */
int zc; /* count of zero cross */
a = recog->adin;
/*
* there are 3 buffers:
* temporary storage queue: buffer[]
* cycle buffer for zero-cross counting: (in zc_e)
* swap buffer for re-starting after short tail silence
*
* Each samples are first read to buffer[], then passed to count_zc_e()
* to find trigger. Samples between trigger and end of speech are
* passed to (*ad_process) with pointer to the first sample and its length.
*
*/
if (a->need_init) {
a->bpmax = MAXSPEECHLEN;
a->bp = 0;
a->is_valid_data = FALSE;
/* reset zero-cross status */
if (a->adin_cut_on) {
reset_count_zc_e(&(a->zc), a->thres, a->c_length, a->c_offset);
}
a->end_of_stream = FALSE;
a->nc = 0;
a->sblen = 0;
a->need_init = FALSE; /* for next call */
}
/****************/
/* resume input */
/****************/
// if (!a->adin_cut_on && a->is_valid_data == TRUE) {
// callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
// }
/*************/
/* main loop */
/*************/
for (;;) {
/* check end of input by end of stream */
if (a->end_of_stream && a->bp == 0) break;
/****************************/
/* read in new speech input */
/****************************/
if (a->end_of_stream) {
/* already reaches end of stream, just process the rest */
a->current_len = a->bp;
} else {
/*****************************************************/
/* get samples from input device to temporary buffer */
/*****************************************************/
/* buffer[0..bp] is the current remaining samples */
/*
mic input - samples exist in a device buffer
tcpip input - samples exist in a socket
file input - samples in a file
Return value is the number of read samples.
If no data exists in the device (in case of mic input), ad_read()
will return 0. If reached end of stream (in case end of file or
receive end ack from tcpip client), it will return -1.
If error, returns -2. If the device requests segmentation, returns -3.
*/
if (a->down_sample) {
/* get 48kHz samples to temporal buffer */
cnt = (*(a->ad_read))(a->buffer48, (a->bpmax - a->bp) * a->io_rate);
} else {
cnt = (*(a->ad_read))(&(a->buffer[a->bp]), a->bpmax - a->bp);
}
if (cnt < 0) { /* end of stream / segment or error */
/* set the end status */
switch(cnt) {
case -1: /* end of stream */
a->input_side_segment = FALSE;
end_status = 0;
break;
case -2:
a->input_side_segment = FALSE;
end_status = -1;
break;
case -3:
a->input_side_segment = TRUE;
end_status = 0;
}
/* now the input has been ended,
we should not get further speech input in the next loop,
instead just process the samples in the temporary buffer until
the entire data is processed. */
a->end_of_stream = TRUE;
cnt = 0; /* no new input */
/* in case the first trial of ad_read() fails, exit this loop */
if (a->bp == 0) break;
}
if (a->down_sample && cnt != 0) {
/* convert to 16kHz */
cnt = ds48to16(&(a->buffer[a->bp]), a->buffer48, cnt, a->bpmax - a->bp, a->ds);
if (cnt < 0) { /* conversion error */
jlog("ERROR: adin_cut: error in down sampling\n");
end_status = -1;
a->end_of_stream = TRUE;
cnt = 0;
if (a->bp == 0) break;
}
}
if (cnt > 0 && a->level_coef != 1.0) {
/* scale the level of incoming input */
for (i = a->bp; i < a->bp + cnt; i++) {
a->buffer[i] = (SP16) ((float)a->buffer[i] * a->level_coef);
}
}
/*************************************************/
/* execute callback here for incoming raw data stream.*/
/* the content of buffer[bp...bp+cnt-1] or the */
/* length can be modified in the functions. */
/*************************************************/
if (cnt > 0) {
#ifdef ENABLE_PLUGIN
plugin_exec_adin_captured(&(a->buffer[a->bp]), cnt);
#endif
callback_exec_adin(CALLBACK_ADIN_CAPTURED, recog, &(a->buffer[a->bp]), cnt);
/* record total number of captured samples */
a->total_captured_len += cnt;
}
/*************************************************/
/* some speech processing for the incoming input */
/*************************************************/
if (cnt > 0) {
if (a->strip_flag) {
/* strip off successive zero samples */
len = strip_zero(&(a->buffer[a->bp]), cnt);
if (len != cnt) cnt = len;
}
if (a->need_zmean) {
/* remove DC offset */
sub_zmean(&(a->buffer[a->bp]), cnt);
}
}
/* current len = current samples in buffer */
a->current_len = a->bp + cnt;
}
#ifdef THREAD_DEBUG
if (a->end_of_stream) {
jlog("DEBUG: adin_cut: stream already ended\n");
}
if (cnt > 0) {
jlog("DEBUG: adin_cut: get %d samples [%d-%d]\n", a->current_len - a->bp, a->bp, a->current_len);
}
#endif
/**************************************************/
/* call the periodic callback (non threaded mode) */
/*************************************************/
/* this function is mainly for periodic checking of incoming command
in module mode */
/* in threaded mode, this will be done in process thread, not here in adin thread */
if (ad_check != NULL
#ifdef HAVE_PTHREAD
&& !a->enable_thread
#endif
) {
/* if ad_check() returns value < 0, termination of speech input is required */
if ((i = (*ad_check)(recog)) < 0) { /* -1: soft termination -2: hard termination */
// if ((i == -1 && current_len == 0) || i == -2) {
if (i == -2 ||
(i == -1 && a->is_valid_data == FALSE)) {
end_status = -2; /* recognition terminated by outer function */
/* execute callback */
if (a->current_len > 0) {
callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
}
a->need_init = TRUE; /* bufer status shoule be reset at next call */
goto break_input;
}
}
}
/***********************************************************************/
/* if no data has got but not end of stream, repeat next input samples */
/***********************************************************************/
if (a->current_len == 0) continue;
/* When not adin_cut mode, all incoming data is valid.
So is_valid_data should be set to TRUE when some input first comes
till this input ends. So, if some data comes, set is_valid_data to
TRUE here. */
if (!a->adin_cut_on && a->is_valid_data == FALSE && a->current_len > 0) {
a->is_valid_data = TRUE;
callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
}
/******************************************************/
/* prepare for processing samples in temporary buffer */
/******************************************************/
wstep = a->chunk_size; /* process unit (should be smaller than cycle buffer) */
/* imax: total length that should be processed at one ad_read() call */
/* if in real-time mode and not threaded, recognition process
will be called and executed as the ad_process() callback within
this function. If the recognition speed is over the real time,
processing all the input samples at the loop below may result in the
significant delay of getting next input, that may result in the buffer
overflow of the device (namely a microphone device will suffer from
this). So, in non-threaded mode, in order to avoid buffer overflow and
input frame dropping, we will leave here by processing
only one segment [0..wstep], and leave the rest in the temporary buffer.
*/
#ifdef HAVE_PTHREAD
if (a->enable_thread) imax = a->current_len; /* process whole */
else imax = (a->current_len < wstep) ? a->current_len : wstep; /* one step */
#else
imax = (a->current_len < wstep) ? a->current_len : wstep; /* one step */
#endif
/* wstep: unit length for the loop below */
if (wstep > a->current_len) wstep = a->current_len;
#ifdef THREAD_DEBUG
jlog("DEBUG: process %d samples by %d step\n", imax, wstep);
#endif
#ifdef HAVE_PTHREAD
if (a->enable_thread) {
/* get transfer status to local */
pthread_mutex_lock(&(a->mutex));
transfer_online_local = a->transfer_online;
pthread_mutex_unlock(&(a->mutex));
}
#endif
/*********************************************************/
/* start processing buffer[0..current_len] by wstep step */
/*********************************************************/
i = 0;
while (i + wstep <= imax) {
if (a->adin_cut_on) {
/********************/
/* check triggering */
/********************/
/* the cycle buffer in count_zc_e() holds the last
samples of (head_margin) miliseconds, and the zerocross
over the threshold level are counted within the cycle buffer */
/* store the new data to cycle buffer and update the count */
/* return zero-cross num in the cycle buffer */
zc = count_zc_e(&(a->zc), &(a->buffer[i]), wstep);
if (zc > a->noise_zerocross) { /* now triggering */
if (a->is_valid_data == FALSE) {
/*****************************************************/
/* process off, trigger on: detect speech triggering */
/*****************************************************/
a->is_valid_data = TRUE; /* start processing */
a->nc = 0;
#ifdef THREAD_DEBUG
jlog("DEBUG: detect on\n");
#endif
/* record time */
a->last_trigger_sample = a->total_captured_len - a->current_len + i + wstep - a->zc.valid_len;
callback_exec(CALLBACK_EVENT_SPEECH_START, recog);
a->last_trigger_len = 0;
if (a->zc.valid_len > wstep) {
a->last_trigger_len += a->zc.valid_len - wstep;
}
/****************************************/
/* flush samples stored in cycle buffer */
/****************************************/
/* (last (head_margin) msec samples */
/* if threaded mode, processing means storing them to speech[].
if ignore_speech_while_recog is on (default), ignore the data
if transfer is offline (=while processing second pass).
Else, datas are stored even if transfer is offline */
if ( ad_process != NULL
#ifdef HAVE_PTHREAD
&& (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
) {
/* copy content of cycle buffer to cbuf */
zc_copy_buffer(&(a->zc), a->cbuf, &len);
/* Note that the last 'wstep' samples are the same as
the current samples 'buffer[i..i+wstep]', and
they will be processed later. So, here only the samples
cbuf[0...len-wstep] will be processed
*/
if (len - wstep > 0) {
#ifdef THREAD_DEBUG
jlog("DEBUG: callback for buffered samples (%d bytes)\n", len - wstep);
#endif
#ifdef ENABLE_PLUGIN
plugin_exec_adin_triggered(a->cbuf, len - wstep);
#endif
callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, a->cbuf, len - wstep);
ad_process_ret = (*ad_process)(a->cbuf, len - wstep, recog);
switch(ad_process_ret) {
case 1: /* segmentation notification from process callback */
#ifdef HAVE_PTHREAD
if (a->enable_thread) {
/* in threaded mode, just stop transfer */
pthread_mutex_lock(&(a->mutex));
a->transfer_online = transfer_online_local = FALSE;
pthread_mutex_unlock(&(a->mutex));
} else {
/* in non-threaded mode, set end status and exit loop */
end_status = 2;
adin_purge(a, i);
goto break_input;
}
break;
#else
/* in non-threaded mode, set end status and exit loop */
end_status = 2;
adin_purge(a, i);
goto break_input;
#endif
case -1: /* error occured in callback */
/* set end status and exit loop */
end_status = -1;
goto break_input;
}
}
}
} else { /* is_valid_data == TRUE */
/******************************************************/
/* process on, trigger on: we are in a speech segment */
/******************************************************/
if (a->nc > 0) {
/*************************************/
/* re-triggering in trailing silence */
/*************************************/
#ifdef THREAD_DEBUG
jlog("DEBUG: re-triggered\n");
#endif
/* reset noise counter */
a->nc = 0;
if (a->sblen > 0) {
a->last_trigger_len += a->sblen;
}
#ifdef TMP_FIX_200602
if (ad_process != NULL
#ifdef HAVE_PTHREAD
&& (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
) {
#endif
/*************************************************/
/* process swap buffer stored while tail silence */
/*************************************************/
/* In trailing silence, the samples within the tail margin length
will be processed immediately, but samples after the tail
margin will not be processed, instead stored in swapbuf[].
If re-triggering occurs while in the trailing silence,
the swapped samples should be processed now to catch up
with current input
*/
if (a->sblen > 0) {
#ifdef THREAD_DEBUG
jlog("DEBUG: callback for swapped %d samples\n", a->sblen);
#endif
#ifdef ENABLE_PLUGIN
plugin_exec_adin_triggered(a->swapbuf, a->sblen);
#endif
callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, a->swapbuf, a->sblen);
ad_process_ret = (*ad_process)(a->swapbuf, a->sblen, recog);
a->sblen = 0;
switch(ad_process_ret) {
case 1: /* segmentation notification from process callback */
#ifdef HAVE_PTHREAD
if (a->enable_thread) {
/* in threaded mode, just stop transfer */
pthread_mutex_lock(&(a->mutex));
a->transfer_online = transfer_online_local = FALSE;
pthread_mutex_unlock(&(a->mutex));
} else {
/* in non-threaded mode, set end status and exit loop */
end_status = 2;
adin_purge(a, i);
goto break_input;
}
break;
#else
/* in non-threaded mode, set end status and exit loop */
end_status = 2;
adin_purge(a, i);
goto break_input;
#endif
case -1: /* error occured in callback */
/* set end status and exit loop */
end_status = -1;
goto break_input;
}
}
#ifdef TMP_FIX_200602
}
#endif
}
}
} else if (a->is_valid_data == TRUE) {
/*******************************************************/
/* process on, trigger off: processing tailing silence */
/*******************************************************/
#ifdef THREAD_DEBUG
jlog("DEBUG: TRAILING SILENCE\n");
#endif
if (a->nc == 0) {
/* start of tail silence: prepare valiables for start swapbuf[] */
a->rest_tail = a->sbsize - a->c_length;
a->sblen = 0;
#ifdef THREAD_DEBUG
jlog("DEBUG: start tail silence, rest_tail = %d\n", a->rest_tail);
#endif
}
/* increment noise counter */
a->nc++;
}
} /* end of triggering handlers */
/********************************************************************/
/* process the current segment buffer[i...i+wstep] if process == on */
/********************************************************************/
if (a->adin_cut_on && a->is_valid_data && a->nc > 0 && a->rest_tail == 0) {
/* The current trailing silence is now longer than the user-
specified tail margin length, so the current samples
should not be processed now. But if 're-triggering'
occurs in the trailing silence later, they should be processed
then. So we just store the overed samples in swapbuf[] and
not process them now */
#ifdef THREAD_DEBUG
jlog("DEBUG: tail silence over, store to swap buffer (nc=%d, rest_tail=%d, sblen=%d-%d)\n", a->nc, a->rest_tail, a->sblen, a->sblen+wstep);
#endif
if (a->sblen + wstep > a->sbsize) {
jlog("ERROR: adin_cut: swap buffer for re-triggering overflow\n");
}
memcpy(&(a->swapbuf[a->sblen]), &(a->buffer[i]), wstep * sizeof(SP16));
a->sblen += wstep;
} else {
/* we are in a normal speech segment (nc == 0), or
trailing silence (shorter than tail margin length) (nc>0,rest_tail>0)
The current trailing silence is shorter than the user-
specified tail margin length, so the current samples
should be processed now as same as the normal speech segment */
#ifdef TMP_FIX_200602
if (!a->adin_cut_on || a->is_valid_data == TRUE) {
#else
if(
(!a->adin_cut_on || a->is_valid_data == TRUE)
#ifdef HAVE_PTHREAD
&& (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
) {
#endif
if (a->nc > 0) {
/* if we are in a trailing silence, decrease the counter to detect
start of swapbuf[] above */
if (a->rest_tail < wstep) a->rest_tail = 0;
else a->rest_tail -= wstep;
#ifdef THREAD_DEBUG
jlog("DEBUG: %d processed, rest_tail=%d\n", wstep, a->rest_tail);
#endif
}
a->last_trigger_len += wstep;
#ifdef TMP_FIX_200602
if (ad_process != NULL
#ifdef HAVE_PTHREAD
&& (!a->enable_thread || !a->ignore_speech_while_recog || transfer_online_local)
#endif
) {
#else
if ( ad_process != NULL ) {
#endif
#ifdef THREAD_DEBUG
jlog("DEBUG: callback for input sample [%d-%d]\n", i, i+wstep);
#endif
/* call external function */
#ifdef ENABLE_PLUGIN
plugin_exec_adin_triggered(&(a->buffer[i]), wstep);
#endif
callback_exec_adin(CALLBACK_ADIN_TRIGGERED, recog, &(a->buffer[i]), wstep);
ad_process_ret = (*ad_process)(&(a->buffer[i]), wstep, recog);
switch(ad_process_ret) {
case 1: /* segmentation notification from process callback */
#ifdef HAVE_PTHREAD
if (a->enable_thread) {
/* in threaded mode, just stop transfer */
pthread_mutex_lock(&(a->mutex));
a->transfer_online = transfer_online_local = FALSE;
pthread_mutex_unlock(&(a->mutex));
} else {
/* in non-threaded mode, set end status and exit loop */
adin_purge(a, i+wstep);
end_status = 2;
goto break_input;
}
break;
#else
/* in non-threaded mode, set end status and exit loop */
adin_purge(a, i+wstep);
end_status = 2;
goto break_input;
#endif
case -1: /* error occured in callback */
/* set end status and exit loop */
end_status = -1;
goto break_input;
}
}
}
} /* end of current segment processing */
if (a->adin_cut_on && a->is_valid_data && a->nc >= a->nc_max) {
/*************************************/
/* process on, trailing silence over */
/* = end of input segment */
/*************************************/
#ifdef THREAD_DEBUG
jlog("DEBUG: detect off\n");
#endif
/* end input by silence */
a->is_valid_data = FALSE; /* turn off processing */
a->sblen = 0;
callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
#ifdef HAVE_PTHREAD
if (a->enable_thread) { /* just stop transfer */
pthread_mutex_lock(&(a->mutex));
a->transfer_online = transfer_online_local = FALSE;
pthread_mutex_unlock(&(a->mutex));
} else {
adin_purge(a, i+wstep);
end_status = 1;
goto break_input;
}
#else
adin_purge(a, i+wstep);
end_status = 1;
goto break_input;
#endif
}
/*********************************************************/
/* end of processing buffer[0..current_len] by wstep step */
/*********************************************************/
i += wstep; /* increment to next wstep samples */
}
/* purge processed samples and update queue */
adin_purge(a, i);
}
break_input:
/****************/
/* pause input */
/****************/
if (a->end_of_stream) { /* input already ends */
/* execute callback */
callback_exec(CALLBACK_EVENT_SPEECH_STOP, recog);
if (a->bp == 0) { /* rest buffer successfully flushed */
/* reset status */
a->need_init = TRUE; /* bufer status shoule be reset at next call */
}
if (end_status >= 0) {
end_status = (a->bp) ? 1 : 0;
}
}
return(end_status);
}
#ifdef HAVE_PTHREAD
/***********************/
/* threading functions */
/***********************/
/*************************/
/* adin thread functions */
/*************************/
/**
* <EN>
* Callback to store triggered samples within A/D-in thread.
* </EN>
* <JA>
* A/D-in スレッドにてトリガした入力サンプルを保存するコールバック.
* </JA>
*
* @param now [in] triggered fragment
* @param len [in] length of above
* @param recog [in] engine instance
*
* @return always 0, to tell caller to just continue the input
*/
static int
adin_store_buffer(SP16 *now, int len, Recog *recog)
{
ADIn *a;
a = recog->adin;
if (a->speechlen + len > MAXSPEECHLEN) {
/* just mark as overflowed, and continue this thread */
pthread_mutex_lock(&(a->mutex));
a->adinthread_buffer_overflowed = TRUE;
pthread_mutex_unlock(&(a->mutex));
return(0);
}
pthread_mutex_lock(&(a->mutex));
memcpy(&(a->speech[a->speechlen]), now, len * sizeof(SP16));
a->speechlen += len;
pthread_mutex_unlock(&(a->mutex));
#ifdef THREAD_DEBUG
jlog("DEBUG: input: stored %d samples, total=%d\n", len, a->speechlen);
#endif
return(0); /* continue */
}
/**
* <EN>
* A/D-in thread main function.
* </EN>
* <JA>
* A/D-in スレッドのメイン関数.
* </JA>
*
* @param dummy [in] a dummy data, not used.
*/
static void
adin_thread_input_main(void *dummy)
{
Recog *recog;
int ret;
recog = dummy;
ret = adin_cut(adin_store_buffer, NULL, recog);
if (ret == -2) { /* termination request by ad_check? */
jlog("Error: adin thread exit with termination request by checker\n");
} else if (ret == -1) { /* error */
jlog("Error: adin thread exit with error\n");
} else if (ret == 0) { /* EOF */
jlog("Stat: adin thread end with EOF\n");
}
recog->adin->adinthread_ended = TRUE;
/* return to end this thread */
}