void CA_DetachCMSfromUtterance(CA_Wave *hWave, CA_Utterance *hUtt)
{
TRY_CA_EXCEPT
ASSERT(hWave);
if (hWave->is_configuredForAgc == False)
SERVICE_ERROR(UNCONFIGURED_CMS_AND_AGC);
if (hUtt && hUtt->data.gen_utt.do_channorm == False)
SERVICE_ERROR(UTTERANCE_INVALID);
if (hWave->is_attached == False)
SERVICE_ERROR(UNATTACHED_CMS_AND_AGC);
if (hWave->data.channel->spchchan && hUtt->data.gen_utt.spchchan
&& hWave->data.channel->spchchan != hUtt->data.gen_utt.spchchan)
{
log_report("Mismatched channel and utterance\n");
SERVICE_ERROR(BAD_CHANNEL);
} /* TODO: find a better code */
hUtt->data.gen_utt.channorm = NULL;
hUtt->data.gen_utt.spchchan = NULL;
hUtt->data.gen_utt.do_channorm = False;
hWave->is_attached = False;
return;
BEG_CATCH_CA_EXCEPT;
END_CATCH_CA_EXCEPT(hWave)
}
void CA_SetupPatternForAcoustic(CA_Pattern *hPattern, CA_Acoustic *hAcoust)
{
TRY_CA_EXCEPT
#ifdef SREC_ENGINE_VERBOSE_LOGGING
PLogMessage("in SetupPatternForAcoustic\n");
#endif
/* Setup for mul-table if necessary
*/
ASSERT(hPattern);
ASSERT(hAcoust);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
if (hAcoust->is_loaded == False)
SERVICE_ERROR(ACOUSTIC_NOT_LOADED);
/* Check that if the Acoustic object is already set up then
the pattern objects must have certain similarities. */
if (hAcoust->pattern_setup_count > 0)
{
if (hPattern->data.prep->imelda_scale != hAcoust->imelda_scale)
SERVICE_ERROR(ACOUSTIC_PATTERN_MISMATCH);
if (hPattern->data.prep->use_dim != hAcoust->use_dim)
SERVICE_ERROR(ACOUSTIC_PATTERN_MISMATCH);
}
#ifdef SREC_ENGINE_VERBOSE_LOGGING
//PLogMessage("mod_style %d\n", hAcoust->acc.mod_style);
#endif
hAcoust->pattern_setup_count++;
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
void CA_AttachCMStoUtterance(CA_Wave *hWave, CA_Utterance *hUtt)
{
/* Link the utt's spchchan to the wave object's. This is checked in AGC fn
to ensure that the correct Utt & Wave objects have been supplied.
*/
TRY_CA_EXCEPT
ASSERT(hUtt);
ASSERT(hWave);
if (hWave->is_configuredForAgc == False)
SERVICE_ERROR(UNCONFIGURED_CMS_AND_AGC);
if (hWave->is_attached == True)
SERVICE_ERROR(ATTACHED_CMS_AND_AGC);
ASSERT(hWave->data.channel->channorm);
hUtt->data.gen_utt.spchchan = hWave->data.channel->spchchan;
hUtt->data.gen_utt.channorm = hWave->data.channel->channorm;
hUtt->data.gen_utt.swicms = hWave->data.channel->swicms;
hUtt->data.gen_utt.do_channorm = True;
#if NORM_IN_IMELDA /* TODO: find appropriate number */
hUtt->data.gen_utt.num_chan = 3 * hWave->data.channel->mel_dim;
#else
hUtt->data.gen_utt.num_chan = hWave->data.channel->mel_dim;
#endif
hWave->is_configuredForAgc = True;
hWave->is_attached = True;
return;
BEG_CATCH_CA_EXCEPT;
END_CATCH_CA_EXCEPT(hFrontend);
}
int CA_AddUttSegmentsToAcousticWhole(CA_Acoustic *hAcoust, CA_Pattern *hPattern,
CA_Utterance *hUtt, CA_Annotation *hAnnotation)
{
int retCode;
TRY_CA_EXCEPT
ASSERT(hAcoust);
ASSERT(hPattern);
ASSERT(hUtt);
ASSERT(hAnnotation);
if (hPattern->setup_whole)
SERVICE_ERROR(PATTERN_ALREADY_SETUP);
if (!hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_NO_SEGMENTS);
}
if (!hAnnotation->label)
SERVICE_ERROR(ANNOTATE_NO_LABEL);
if (CA_IsAcousticWholeModelExtant(hAcoust, hAnnotation->label))
return (0); /* TODO: ERROR CODE? */
if (!hAcoust->acc.base_model)
{
hAcoust->acc.base_model = allocate_hmm(0, &hAcoust->acc.base_sort);
hAcoust->acc.base_model->dim = hPattern->data.prep->dim;
hAcoust->acc.num_pars = hAcoust->acc.base_model->dim;
hAcoust->acc.mod_type = SEGM;
hAcoust->acc.mod_style = SEG_STYLE;
#if USE_CONTEXT_MASK
construct_context_groups_for_wholeword(&hAcoust->acc);
#endif
}
else
if (hAcoust->acc.base_model->dim != hPattern->data.prep->dim)
SERVICE_ERROR(UTTERANCE_DIMEN_MISMATCH);
/* Redundant. We now add the whole set of segments.
if ((id < 0) || (id >= hAnnotation->data->numWords))
SERVICE_ERROR ( BAD_INDEX );
*/
/* This fn now returns number of models added */
retCode = annotation_add_utt_segment_to_acoustic(&hAcoust->acc,
hPattern->data.prep,
&hUtt->data,
hAnnotation->data,
hAnnotation->label,
hAcoust->has_backup_means);
if (retCode > 0)
{
hAcoust->is_loaded = True;
}
return retCode;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAcoust)
}
void CA_ReLoadCMSParameters(CA_Wave *hWave, const char *basename)
{
ASSERT(hWave);
if (hWave->is_configuredForAgc == False)
SERVICE_ERROR(UNCONFIGURED_CMS_AND_AGC);
if (!basename) {
if( swicms_init(hWave->data.channel->swicms) )
SERVICE_ERROR(UNEXPECTED_DATA_ERROR);
}
else
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
}
void CA_ClearPatternForAcoustic(CA_Pattern *hPattern, CA_Acoustic *hAcoust)
{
TRY_CA_EXCEPT
ASSERT(hPattern);
ASSERT(hAcoust);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
if (hAcoust->pattern_setup_count == 0)
SERVICE_ERROR(ACOUSTIC_HAS_NO_PATTERN);
hAcoust->pattern_setup_count--;
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
int CA_LoadTransform(CA_Transform *hTransform, int dimen)
{
TRY_CA_EXCEPT
ASSERT(hTransform);
ASSERT(dimen > 0);
if (hTransform->is_loaded == True)
SERVICE_ERROR(PATTERN_ALREADY_LOADED);
hTransform->dim = dimen;
hTransform->imelda_acc.between = create_accumulate_matrix(hTransform->dim);
hTransform->imelda_acc.bmean = (accdata *) VAR_ALLOCATE(hTransform->dim,
sizeof(accdata), "ca.hTransform->imelda_acc.bmean");
hTransform->imelda_acc.within = create_accumulate_matrix(dimen);
hTransform->imelda_acc.wmean = (accdata *) VAR_ALLOCATE(hTransform->dim,
sizeof(accdata), "ca.hTransform->imelda_acc.wmean");
hTransform->mllr_acc.between = create_accumulate_matrix(hTransform->dim + 1);
hTransform->mllr_acc.within = create_accumulate_matrix(hTransform->dim + 1);
hTransform->is_loaded = True;
return (True);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hTransform)
}
int CA_GetAnnotationLabel(CA_Annotation *hAnnotation, char *label, int length)
{
int required_length;
TRY_CA_EXCEPT
ASSERT(hAnnotation);
ASSERT(label);
if (length <= 0)
SERVICE_ERROR(BAD_ARGUMENT);
if (hAnnotation->label)
{
required_length = strlen(hAnnotation->label) + 1;
if (required_length > length)
{
if (length > 1)
{
strncpy(label, hAnnotation->label, length - 2);
label[length - 1] = '\0';
}
else
*label = '\0';
return (required_length);
}
else
strcpy(label, hAnnotation->label);
return (0);
}
*label = '\0';
return (0);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
void CA_UnloadPattern(CA_Pattern *hPattern)
{
TRY_CA_EXCEPT
ASSERT(hPattern);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
if (--hPattern->data.prep->ref_count == 0)
{
if (hPattern->data.prep->matrix)
free_linear_transform(hPattern->data.prep);
if (hPattern->data.prep->add.table)
destroy_lookup_logadd(&hPattern->data.prep->add);
clear_preprocessed(hPattern->data.prep);
FREE((char *) hPattern->data.prep);
hPattern->data.prep = NULL;
}
hPattern->is_loaded = False;
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
int CA_AnnotateFromVoicing(CA_Annotation* hAnnotation, CA_Utterance *hUtterance, CA_Pattern *hPattern)
{
TRY_CA_EXCEPT
ASSERT(hAnnotation);
ASSERT(hUtterance);
ASSERT(hPattern);
if (hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_SEGMENTS_EXIST);
}
annotation_from_voicing(hAnnotation->data, &hUtterance->data, hPattern->data.prep);
if (hAnnotation->data->numWords > 0)
{
hAnnotation->has_segments = True;
}
return (hAnnotation->data->numWords);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
int CA_AnnotateFromResults(CA_Annotation* hAnnotation, CA_Recog *hRecog)
{
TRY_CA_EXCEPT
int seg_cnt = 0;
ASSERT(hRecog);
ASSERT(hAnnotation);
if (hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_SEGMENTS_EXIST);
}
seg_cnt = annotation_from_results(hAnnotation->data, &hRecog->rec);
if (hAnnotation->data->numWords > 0)
{
annotation_decorate_labels(hAnnotation->data, hAnnotation->label);
hAnnotation->has_segments = True;
}
return (hAnnotation->data->numWords);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
int CA_MakePatternFrame(CA_Pattern *hPattern, CA_Utterance *hUtt)
{
TRY_CA_EXCEPT
int status_code;
swicms_norm_info* swicms;
ASSERT(hPattern);
ASSERT(hUtt);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
status_code = get_data_frame(hPattern->data.prep, &hUtt->data);
/* swicms_cache_frame() must be here because get_data_frame() is called from
backtracing. Is the caching at the front-end even necessary any more?
*/
swicms = hUtt->data.gen_utt.swicms;
if (!swicms->is_valid)
swicms_lda_process(swicms, hPattern->data.prep);
swicms_cache_frame(swicms, hPattern->data.prep->seq_unnorm,
hUtt->data.gen_utt.channorm->dim);
apply_channel_normalization_in_swicms(swicms, hPattern->data.prep->seq,
hPattern->data.prep->seq_unnorm,
hUtt->data.gen_utt.channorm->dim);
/* prepare is fairly useless and should be removed */
prepare_data_frame(hPattern->data.prep);
return (status_code);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
int get_data_frame(preprocessed *prep, utterance_info *utt)
/*
** To get a frame amount of data and perform preprocessing functions
*/
{
int status_code;
ASSERT(prep);
ASSERT(utt);
if (utt->gen_utt.channorm && !utt->gen_utt.channorm->adj_valid)
convert_adjustment_to_imelda(utt->gen_utt.channorm, prep);
if (utt->gen_utt.dim != prep->dim)
SERVICE_ERROR(UTTERANCE_DIMEN_MISMATCH);
if (prep->post_proc & VFR)
{
if ((status_code = get_utterance_frame(prep, utt)) <= 0)
return (status_code);
log_report("get_data_frame vfr not supported\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
}
else
{
status_code = get_utterance_frame(prep, utt);
if (status_code == 0) return(status_code);
else if (status_code == -1) return(1);
}
if (prep->chan_offset)
apply_channel_offset(prep);
/* Apply linear transformation if necessary
*/
if (prep->post_proc & LIN_TRAN)
linear_transform_frame(prep, prep->seq, True);
memcpy(prep->seq_unnorm, prep->seq, prep->dim * sizeof(imeldata));
if (utt->gen_utt.channorm)
apply_channel_normalization_in_imelda(utt->gen_utt.channorm,
prep->seq, prep->seq_unnorm,
utt->gen_utt.channorm->dim);
return (1);
}
/*****************************************************************************************
* TODO : wrap this into a lower level function
*****************************************************************************************/
void CA_GetAnnotationData(CA_Annotation* hAnnotation, int id,
int* begin, int* end, char* buff, int buffLen)
{
TRY_CA_EXCEPT
ASSERT(hAnnotation);
if ((id < 0) || (id >= hAnnotation->data->numWords))
SERVICE_ERROR(BAD_INDEX);
if (!hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_NO_SEGMENTS);
}
annotation_get_data(hAnnotation->data, id, begin, end, buff, buffLen);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
void CA_LoadModelsInAcoustic(CA_Recog *hRecog, CA_Acoustic *hAcoust,
CA_AcoustInputParams *hAcoustInp)
{
int rc;
TRY_CA_EXCEPT
ASSERT(hRecog);
ASSERT(hAcoust);
ASSERT(hAcoustInp);
if (hAcoust->is_loaded == False)
SERVICE_ERROR(ACOUSTIC_NOT_LOADED);
if (hAcoustInp->is_loaded == False)
SERVICE_ERROR(ACOUSTIC_INPUT_NOT_LOADED);
// returns 1 for OK, 0 if not OK
rc = add_acoustic_model_for_recognition(hRecog->recm, hAcoust->swimodel);
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hRecog)
}
void CA_UnloadAcoustic(CA_Acoustic *hAcoust)
{
TRY_CA_EXCEPT
ASSERT(hAcoust);
if (hAcoust->is_loaded == False)
SERVICE_ERROR(ACOUSTIC_NOT_LOADED);
if (hAcoust->swimodel)
{
free_swimodel(hAcoust->swimodel);
hAcoust->swimodel = 0;
hAcoust->is_loaded = False;
return;
}
else
SERVICE_ERROR(ACOUSTIC_NOT_LOADED);
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAcoust)
}
void CA_LoadCMSParameters(CA_Wave *hWave, const char *basename,
CA_FrontendInputParams *hFrontArgs)
{
TRY_CA_EXCEPT
#if !defined(_RTT)
ASSERT(hWave);
/* ASSERT (basename); */
ASSERT(hFrontArgs);
if (hWave->is_configuredForAgc == True)
SERVICE_ERROR(CONFIGURED_CMS_AND_AGC);
if (hWave->is_attached == True)
SERVICE_ERROR(ATTACHED_CMS_AND_AGC);
hWave->data.channel->channorm = create_channel_normalization();
/* load_channel_parameters (basename, hWave->data.channel->channorm);
not used anymore, rather we spec this is the parfile directly */
hWave->data.channel->channorm->dim = MAX_CHAN_DIM;
setup_channel_normalization(hWave->data.channel->channorm,
hWave->data.channel->spchchan,
#if NORM_IN_IMELDA
hFrontArgs->mel_dim * 3, /* TODO: find appropriate number */
#else
hFrontArgs->mel_dim,
#endif
hFrontArgs->forget_factor);
hWave->data.channel->mel_dim = hFrontArgs->mel_dim; /* TODO: more checks */
hWave->data.channel->swicms = (swicms_norm_info*)CALLOC(1, sizeof(swicms_norm_info), "cfront.swicms");
if( swicms_init(hWave->data.channel->swicms) )
SERVICE_ERROR(UNEXPECTED_DATA_ERROR);
hWave->is_configuredForAgc = True;
#else
log_report("Channel normalization or RTT not in module\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
#endif
BEG_CATCH_CA_EXCEPT;
END_CATCH_CA_EXCEPT(hFrontend);
}
void CA_SaveAnnotation(CA_Annotation* hAnnotation, char* FileName)
{
TRY_CA_EXCEPT
#ifndef _RTT
ASSERT(hAnnotation);
if (!hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_NO_SEGMENTS);
}
save_annotations(hAnnotation->data, FileName);
return;
#else
log_report("RTT not in module\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
return;
#endif
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
void CA_ClearCMSParameters(CA_Wave *hWave)
{
TRY_CA_EXCEPT
#if NORM_IN_IMELDA
int dim = hWave->data.channel->mel_dim * 3;
#else
int dim = hWave->data.channel->mel_dim;
#endif
ASSERT(hWave);
if (hWave->is_configuredForAgc == False)
SERVICE_ERROR(UNCONFIGURED_CMS_AND_AGC);
if (hWave->is_attached == True)
SERVICE_ERROR(ATTACHED_CMS_AND_AGC);
clear_channel_normalization(hWave->data.channel->spchchan, dim);
destroy_channel_normalization(hWave->data.channel->channorm);
hWave->data.channel->channorm = NULL;
hWave->is_configuredForAgc = False;
FREE(hWave->data.channel->swicms);
BEG_CATCH_CA_EXCEPT;
END_CATCH_CA_EXCEPT(hWave);
}
void CA_FreeAnnotation(CA_Annotation* hAnnotation)
{
TRY_CA_EXCEPT
ASSERT(hAnnotation);
if (hAnnotation->has_segments)
{
SERVICE_ERROR(ANNOTATE_SEGMENTS_EXIST);
}
free_annotation(hAnnotation->data);
VAR_FREE(hAnnotation, "hAnnotation");
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
void CA_SetAnnotationLabel(CA_Annotation *hAnnotation, char *label)
{
TRY_CA_EXCEPT
ASSERT(hAnnotation);
ASSERT(label);
if ((strchr(label, '<') || (strchr(label, '>'))))
SERVICE_ERROR(BAD_LABEL);
if (hAnnotation->label)
VAR_FREE(hAnnotation, "annotation_label");
hAnnotation->label = NULL;
hAnnotation->label = (char *) VAR_ALLOCATE(strlen(label) + 1, sizeof(char), "ca.annotation_label");
strcpy(hAnnotation->label, label);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hAnnotation)
}
int CA_CompareAnnotations(CA_Annotation *testAnnotation, CA_Annotation *refAnnotation)
{
TRY_CA_EXCEPT
int score;
ASSERT(testAnnotation);
ASSERT(refAnnotation);
if ((!testAnnotation->has_segments) || (!refAnnotation->has_segments))
{
SERVICE_ERROR(ANNOTATE_NO_SEGMENTS);
}
score = annotation_compare(testAnnotation->data, refAnnotation->data);
return (score);
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(testAnnotation)
}
void CA_UnloadTransform(CA_Transform *hTransform)
{
TRY_CA_EXCEPT
ASSERT(hTransform);
if (hTransform->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
delete_accumulate_matrix(hTransform->imelda_acc.between, hTransform->dim);
delete_accumulate_matrix(hTransform->imelda_acc.within, hTransform->dim);
delete_accumulate_matrix(hTransform->mllr_acc.between, hTransform->dim + 1);
delete_accumulate_matrix(hTransform->mllr_acc.within, hTransform->dim + 1);
VAR_FREE(hTransform->imelda_acc.bmean, "hTransform->imelda_acc.bmean");
VAR_FREE(hTransform->imelda_acc.wmean, "hTransform->imelda_acc.wmean");
hTransform->is_loaded = False;
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hTransform)
}
void CA_ClearTransform(CA_Transform *hTransform)
{
TRY_CA_EXCEPT
int ii, jj;
if (hTransform->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform->imelda_acc.within);
ASSERT(hTransform->imelda_acc.between);
ASSERT(hTransform->imelda_acc.wmean);
ASSERT(hTransform->imelda_acc.bmean);
ASSERT(hTransform->mllr_acc.within);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii <= hTransform->dim; ii++)
{
for (jj = 0; jj <= hTransform->dim; jj++)
{
hTransform->mllr_acc.between[ii][jj] = 0;
hTransform->mllr_acc.within[ii][jj] = 0;
}
}
for (ii = 0; ii < hTransform->dim; ii++)
{
hTransform->imelda_acc.wmean[ii] = 0;
hTransform->imelda_acc.bmean[ii] = 0;
for (jj = 0; jj < hTransform->dim; jj++)
{
hTransform->imelda_acc.between[ii][jj] = 0;
hTransform->imelda_acc.within[ii][jj] = 0;
}
}
hTransform->imelda_acc.num = 0;
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hTransform)
}
void init_utterance(utterance_info *utt, int utt_type, int dimen,
int buffer_size, int keep_frames, int num_chan, int do_voicing)
/*
** To setup the utterance structure
*/
{
/* Construct frame buffer and voice buffer here
*/
ASSERT(utt);
ASSERT(dimen > 0);
if (buffer_size < keep_frames)
SERVICE_ERROR(BAD_ARGUMENT);
utt->utt_type = utt_type;
utt->gen_utt.dim = dimen;
utt->gen_utt.frame = createFrameBuffer(buffer_size,
dimen, keep_frames, do_voicing);
utt->gen_utt.num_chan = num_chan;
setup_ambient_estimation(utt->gen_utt.backchan,
utt->gen_utt.num_chan, 100);
return;
}
int CA_ConfigureRecognition(CA_Recog *hRecog, CA_RecInputParams *hRecInput)
{
int rc = 0;
TRY_CA_EXCEPT
if (hRecog->is_configured == True)
SERVICE_ERROR(RECOGNIZER_ALREADY_CONFIGURED);
rc = allocate_recognition(hRecog->recm,
hRecInput->viterbi_prune_thresh,
hRecInput->max_hmm_tokens,
hRecInput->max_fsmnode_tokens,
hRecInput->max_word_tokens,
hRecInput->max_altword_tokens,
hRecInput->num_wordends_per_frame,
hRecInput->max_fsm_nodes,
hRecInput->max_fsm_arcs,
hRecInput->max_frames,
hRecInput->max_model_states,
hRecInput->max_searches);
if (rc) return rc;
/*rc =*/
srec_eosd_allocate(&hRecog->eosd_parms,
hRecInput->eou_threshold,
hRecInput->eou_threshold,
hRecInput->terminal_timeout,
hRecInput->optional_terminal_timeout,
hRecInput->non_terminal_timeout,
hRecInput->max_frames);
if (rc) return rc;
hRecog->is_configured = True;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hRecog)
return 0;
}
int CA_LoadAcousticSub(CA_Acoustic *hAcoust, char *subname, CA_AcoustInputParams *hAcoustInp)
{
//#ifndef _RTT
// int load_genome = 0;
//#endif
if (hAcoustInp == 0)
{
/* SpeechWorks image format! */
hAcoust->swimodel = load_swimodel(subname);
if (hAcoust->swimodel == NULL)
{
// failed to load, load_swimodel will have printed an error to the log
return 0;
}
hAcoust->is_loaded = ESR_TRUE;
return 1;
}
else
{
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
return 0;
}
}
int CA_LoadPattern(CA_Pattern *hPattern, CA_PatInputParams *hPatInput,
int dimen , char *multable , char *imelda)
{
TRY_CA_EXCEPT
#ifndef _RTT
int ii, ret_code;
ASSERT(hPattern);
ASSERT(hPatInput);
if (hPattern->is_loaded == True)
SERVICE_ERROR(PATTERN_ALREADY_LOADED);
if (hPatInput->is_loaded == False)
SERVICE_ERROR(PATTERN_INPUT_NOT_LOADED);
hPattern->data.prep = (preprocessed *) CALLOC_CLR(1,
sizeof(preprocessed), "ca.hPattern->data.prep");
/* Load the Imelda transform if specified */
if (imelda && strlen(imelda) > 0)
{
ret_code = init_newton_transform(hPattern->data.prep, 0, imelda, hPatInput->dimen);
if (ret_code > 0)
SERVICE_ERROR(PATTERN_NOT_LOADED);
}
else
{
hPattern->data.prep->use_dim = hPatInput->dimen;
hPattern->data.prep->use_from = hPatInput->feat_start;
}
if (hPatInput->whole_dimen == 0)
hPattern->data.prep->whole_dim = hPatInput->dimen;
else
hPattern->data.prep->whole_dim = hPatInput->whole_dimen;
if (hPattern->data.prep->whole_dim > hPattern->data.prep->use_dim)
SERVICE_ERROR(BAD_PARAMETER);
hPattern->data.prep->mix_score_scale = (prdata)(128 * hPatInput->mix_score_scale + 0.5)
- (prdata)0.5;
hPattern->data.prep->uni_score_scale = (prdata)(128 * hPatInput->uni_score_scale + 0.5)
- (prdata)0.5;
hPattern->data.prep->uni_score_offset = (prdata) hPatInput->uni_score_offset;
hPattern->data.prep->imelda_scale = (prdata)hPatInput->imelda_scale;
init_preprocessed(hPattern->data.prep, dimen, hPatInput->imelda_scale); /* TODO: move this to Setup */
/* Annotation parameters */
hPattern->data.prep->end.rel_low = hPatInput->rel_low;
hPattern->data.prep->end.rel_high = hPatInput->rel_high;
hPattern->data.prep->end.gap_period = hPatInput->gap_period;
hPattern->data.prep->end.click_period = hPatInput->click_period;
hPattern->data.prep->end.breath_period = hPatInput->breath_period;
hPattern->data.prep->end.extend_annotation = hPatInput->extend_annotation;
hPattern->data.prep->end.min_annotation_frames = hPatInput->min_annotation_frames;
hPattern->data.prep->end.max_annotation_frames = hPatInput->max_annotation_frames;
hPattern->data.prep->end.min_segment_rel_c0 = hPatInput->min_segment_rel_c0;
hPattern->data.prep->end.min_initial_quiet_frames = hPatInput->min_initial_quiet_frames;
hPattern->data.prep->end.delete_leading_segments = hPatInput->delete_leading_segments;
hPattern->data.prep->end.leading_segment_min_frames = hPatInput->leading_segment_min_frames;
hPattern->data.prep->end.leading_segment_max_frames = hPatInput->leading_segment_max_frames;
hPattern->data.prep->end.leading_segment_min_silence_gap_frames
= hPatInput->leading_segment_min_silence_gap_frames;
hPattern->data.prep->end.leading_segment_accept_if_not_found
= hPatInput->leading_segment_accept_if_not_found;
#if DO_SUBTRACTED_SEGMENTATION
hPattern->data.prep->end.snr_holdoff = hPatInput->snr_holdoff;
hPattern->data.prep->end.min_acceptable_snr = hPatInput->min_acceptable_snr;
#endif
hPattern->data.prep->end.param = hPatInput->param;
hPattern->data.prep->end.beep_size = hPatInput->beep_size;
hPattern->data.prep->end.beep_threshold = hPatInput->beep_threshold;
/* log-lookup table */
create_lookup_logadd(&hPattern->data.prep->add, (float)MUL_SCALE);
/* Build the weights conversion table */
for (ii = 0; ii < MAX_WTS; ii++)
hPattern->data.prep->exp_wt[ii] =
(prdata)(WEIGHT_SCALE * exp((double)(0x01 << WT_ADJUST) *
(double) - ii / (MUL_SCALE * hPattern->data.prep->add.scale)) +
0.5) - (prdata)0.5;
hPattern->data.prep->ref_count = 1;
hPattern->is_loaded = True;
return (True);
#else
log_report("RTT not in module\n");
SERVICE_ERROR(FEATURE_NOT_SUPPORTED);
return (False);
#endif
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
void CA_LoadTransformAccumulates(CA_Pattern *hPattern,
CA_Transform *hTransform)
{
TRY_CA_EXCEPT
int ii, jj;
ASSERT(hPattern);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform);
if (hTransform->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform->dim == hPattern->data.dim);
if (hTransform->do_mllr)
{
ASSERT(hPattern->data.do_mllr);
ASSERT(hPattern->data.mllr_acc.between);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii <= hTransform->dim; ii++)
for (jj = 0; jj <= hTransform->dim; jj++)
{
hPattern->data.mllr_acc.between[ii][jj] =
hTransform->mllr_acc.between[ii][jj];
hPattern->data.mllr_acc.within[ii][jj] =
hTransform->mllr_acc.within[ii][jj];
}
}
if (hTransform->do_imelda)
{
ASSERT(hPattern->data.do_imelda);
ASSERT(hPattern->data.mllr_acc.between);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii < hTransform->dim; ii++)
for (jj = 0; jj < hTransform->dim; jj++)
{
hPattern->data.imelda_acc.between[ii][jj] =
hTransform->imelda_acc.between[ii][jj];
hPattern->data.imelda_acc.within[ii][jj] =
hTransform->imelda_acc.within[ii][jj];
}
for (ii = 0; ii < hTransform->dim; ii++)
{
hPattern->data.imelda_acc.bmean[ii] =
hTransform->imelda_acc.bmean[ii];
hPattern->data.imelda_acc.wmean[ii] =
hTransform->imelda_acc.wmean[ii];
}
hPattern->data.imelda_acc.num = hTransform->imelda_acc.num;
}
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
void CA_InheritAccumulates(CA_Transform *hTransform, CA_Pattern *hPattern)
{
TRY_CA_EXCEPT
int ii, jj;
ASSERT(hPattern);
if (hPattern->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform);
if (hTransform->is_loaded == False)
SERVICE_ERROR(PATTERN_NOT_LOADED);
ASSERT(hTransform->dim == hPattern->data.dim);
if (hTransform->do_mllr)
{
ASSERT(hPattern->true_accumulates);
ASSERT(hPattern->data.do_mllr);
ASSERT(hPattern->data.mllr_acc.between);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii <= hTransform->dim; ii++)
for (jj = 0; jj <= hTransform->dim; jj++)
{
hTransform->mllr_acc.between[ii][jj] +=
hPattern->data.mllr_acc.between[ii][jj];
hTransform->mllr_acc.within[ii][jj] +=
hPattern->data.mllr_acc.within[ii][jj];
}
log_report("\nCA_InheritAccumulates MLLR inheriting %f frames (total now %f)\n\n", hPattern->data.mllr_acc.within[hTransform->dim][hTransform->dim], hTransform->mllr_acc.within[hTransform->dim][hTransform->dim]);
}
if (hTransform->do_imelda)
{
ASSERT(hPattern->data.do_imelda);
ASSERT(hPattern->data.mllr_acc.between);
ASSERT(hTransform->mllr_acc.between);
for (ii = 0; ii < hTransform->dim; ii++)
for (jj = 0; jj < hTransform->dim; jj++)
{
hTransform->imelda_acc.between[ii][jj] +=
hPattern->data.imelda_acc.between[ii][jj];
hTransform->imelda_acc.within[ii][jj] +=
hPattern->data.imelda_acc.within[ii][jj];
}
for (ii = 0; ii < hTransform->dim; ii++)
{
hTransform->imelda_acc.bmean[ii] +=
hPattern->data.imelda_acc.bmean[ii];
hTransform->imelda_acc.wmean[ii] +=
hPattern->data.imelda_acc.wmean[ii];
}
hTransform->imelda_acc.num += hPattern->data.imelda_acc.num;
log_report("\nCA_InheritAccumulates Imelda inheriting %d frames (total now %d)\n\n", hPattern->data.imelda_acc.num, hTransform->imelda_acc.num);
}
return;
BEG_CATCH_CA_EXCEPT
END_CATCH_CA_EXCEPT(hPattern)
}
