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) }