/* HTS_Window_load: load dynamic windows */ static HTS_Boolean HTS_Window_load(HTS_Window * win, HTS_File ** fp, int size) { int i, j; int fsize, length; char buff[HTS_MAXBUFLEN]; HTS_Boolean result = TRUE; /* check */ if (win == NULL || fp == NULL || size <= 0) return FALSE; win->size = size; win->l_width = (int *) HTS_calloc(win->size, sizeof(int)); win->r_width = (int *) HTS_calloc(win->size, sizeof(int)); win->coefficient = (double **) HTS_calloc(win->size, sizeof(double *)); /* set delta coefficents */ for (i = 0; i < win->size; i++) { if (HTS_get_token(fp[i], buff) == FALSE) { result = FALSE; fsize = 1; } else { fsize = atoi(buff); if (fsize <= 0) { result = FALSE; fsize = 1; } } /* read coefficients */ win->coefficient[i] = (double *) HTS_calloc(fsize, sizeof(double)); for (j = 0; j < fsize; j++) { if (HTS_get_token(fp[i], buff) == FALSE) { result = FALSE; win->coefficient[i][j] = 0.0; } else { win->coefficient[i][j] = (double) atof(buff); } } /* set pointer */ length = fsize / 2; win->coefficient[i] += length; win->l_width[i] = -length; win->r_width[i] = length; if (fsize % 2 == 0) win->r_width[i]--; } /* calcurate max_width to determine size of band matrix */ win->max_width = 0; for (i = 0; i < win->size; i++) { if (win->max_width < abs(win->l_width[i])) win->max_width = abs(win->l_width[i]); if (win->max_width < abs(win->r_width[i])) win->max_width = abs(win->r_width[i]); } if (result == FALSE) { HTS_Window_clear(win); return FALSE; } return TRUE; }
/* HTS_Engine_load_gv_from_fn: load GV pdfs and trees from file names */ void HTS_Engine_load_gv_from_fn(HTS_Engine * engine, char **pdf_fn, char **tree_fn, int stream_index, int interpolation_size) { int i; FILE **pdf_fp, **tree_fp; pdf_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *)); if (tree_fn) tree_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *)); else tree_fp = NULL; for (i = 0; i < interpolation_size; i++) { pdf_fp[i] = HTS_get_fp(pdf_fn[i], "rb"); if (tree_fn) { if (tree_fn[i]) tree_fp[i] = HTS_get_fp(tree_fn[i], "r"); else tree_fp[i] = NULL; } } HTS_Engine_load_gv_from_fp(engine, pdf_fp, tree_fp, stream_index, interpolation_size); for (i = 0; i < interpolation_size; i++) { fclose(pdf_fp[i]); if (tree_fp && tree_fp[i]) fclose(tree_fp[i]); } HTS_free(pdf_fp); if (tree_fp) HTS_free(tree_fp); }
/* HTS_Engine_load_parameter_from_fn: load parameter pdfs, trees and windows from file names */ void HTS_Engine_load_parameter_from_fn(HTS_Engine * engine, char **pdf_fn, char **tree_fn, char **win_fn, int stream_index, HTS_Boolean msd_flag, int window_size, int interpolation_size) { int i; FILE **pdf_fp, **tree_fp, **win_fp; pdf_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *)); tree_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *)); win_fp = (FILE **) HTS_calloc(window_size, sizeof(FILE *)); for (i = 0; i < interpolation_size; i++) { pdf_fp[i] = HTS_get_fp(pdf_fn[i], "rb"); tree_fp[i] = HTS_get_fp(tree_fn[i], "r"); } for (i = 0; i < window_size; i++) win_fp[i] = HTS_get_fp(win_fn[i], "r"); HTS_Engine_load_parameter_from_fp(engine, pdf_fp, tree_fp, win_fp, stream_index, msd_flag, window_size, interpolation_size); for (i = 0; i < interpolation_size; i++) { fclose(pdf_fp[i]); fclose(tree_fp[i]); } for (i = 0; i < window_size; i++) fclose(win_fp[i]); HTS_free(pdf_fp); HTS_free(tree_fp); HTS_free(win_fp); }
/* HTS_Audio_open: open audio device */ static void HTS_Audio_open(HTS_Audio * audio, int sampling_rate, int max_buff_size) { MMRESULT error; if (audio->sampling_rate == sampling_rate && audio->max_buff_size == max_buff_size) return; HTS_Audio_close(audio); audio->sampling_rate = sampling_rate; audio->max_buff_size = max_buff_size; if (audio->max_buff_size <= 0) return; /* queue */ audio->which_buff = 1; audio->now_buff_1 = FALSE; audio->now_buff_2 = FALSE; audio->buff = (short *) HTS_calloc(max_buff_size, sizeof(short)); /* format */ audio->waveformatex.wFormatTag = WAVE_FORMAT_PCM; audio->waveformatex.nChannels = AUDIO_CHANNEL; audio->waveformatex.nSamplesPerSec = sampling_rate; audio->waveformatex.wBitsPerSample = sizeof(short) * 8; audio->waveformatex.nBlockAlign = AUDIO_CHANNEL * audio->waveformatex.wBitsPerSample / 8; audio->waveformatex.nAvgBytesPerSec = sampling_rate * audio->waveformatex.nBlockAlign; /* open */ error = waveOutOpen(&audio->hwaveout, WAVE_MAPPER, &audio->waveformatex, (DWORD) HTS_Audio_callback_function, (DWORD) audio, CALLBACK_FUNCTION); if (error != MMSYSERR_NOERROR) HTS_error(0, "hts_engine: Failed to open your output audio device to play waveform.\n"); /* prepare */ audio->buff_1.lpData = (LPSTR) HTS_calloc(max_buff_size, sizeof(short)); audio->buff_1.dwBufferLength = max_buff_size * sizeof(short); audio->buff_1.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP; audio->buff_1.dwLoops = 1; audio->buff_1.lpNext = 0; audio->buff_1.reserved = 0; error = waveOutPrepareHeader(audio->hwaveout, &(audio->buff_1), sizeof(WAVEHDR)); if (error != MMSYSERR_NOERROR) HTS_error(0, "hts_engine: Cannot initialize audio datablocks to play waveform.\n"); audio->buff_2.lpData = (LPSTR) HTS_calloc(max_buff_size, sizeof(short)); audio->buff_2.dwBufferLength = max_buff_size * sizeof(short); audio->buff_2.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP; audio->buff_2.dwLoops = 1; audio->buff_2.lpNext = 0; audio->buff_2.reserved = 0; error = waveOutPrepareHeader(audio->hwaveout, &(audio->buff_2), sizeof(WAVEHDR)); if (error != MMSYSERR_NOERROR) HTS_error(0, "hts_engine: Cannot initialize audio datablocks to play waveform.\n"); }
/* HTS_Model_load_tree: load trees */ static void HTS_Model_load_tree(HTS_Model * model, FILE * fp) { char buff[HTS_MAXBUFLEN]; HTS_Question *question, *last_question; HTS_Tree *tree, *last_tree; int state; /* check */ if (fp == NULL) HTS_error(1, "HTS_Model_load_tree: File for trees is not specified.\n"); model->ntree = 0; last_question = NULL; last_tree = NULL; while (!feof(fp)) { HTS_get_pattern_token(fp, buff); /* parse questions */ if (strcmp(buff, "QS") == 0) { question = (HTS_Question *) HTS_calloc(1, sizeof(HTS_Question)); HTS_Question_load(question, fp); if (model->question) last_question->next = question; else model->question = question; question->next = NULL; last_question = question; } /* parse trees */ state = HTS_get_state_num(buff); if (state != 0) { tree = (HTS_Tree *) HTS_calloc(1, sizeof(HTS_Tree)); tree->next = NULL; tree->root = NULL; tree->head = NULL; tree->state = state; HTS_Tree_parse_pattern(tree, buff); HTS_Tree_load(tree, fp, model->question); if (model->tree) last_tree->next = tree; else model->tree = tree; tree->next = NULL; last_tree = tree; model->ntree++; } } /* No Tree information in tree file */ if (model->tree == NULL) HTS_error(1, "HTS_Model_load_tree: No trees are loaded.\n"); }
/* HTS_Audio_open: open audio device */ static void HTS_Audio_open(HTS_Audio * audio, int sampling_rate, int max_buff_size) { if (audio->sampling_rate == sampling_rate && audio->max_buff_size == max_buff_size) return; HTS_Audio_close(audio); audio->sampling_rate = sampling_rate; audio->max_buff_size = max_buff_size; if (audio->max_buff_size <= 0) return; audio->err = Pa_Initialize(); if (audio->err != paNoError) HTS_error(0, "hts_engine: Failed to initialize your output audio device to play waveform.\n"); audio->parameters.device = Pa_GetDefaultOutputDevice(); audio->parameters.channelCount = 1; audio->parameters.sampleFormat = paInt16; audio->parameters.suggestedLatency = Pa_GetDeviceInfo(audio->parameters.device)->defaultLowOutputLatency; audio->parameters.hostApiSpecificStreamInfo = NULL; audio->err = Pa_OpenStream(&audio->stream, NULL, &audio->parameters, sampling_rate, max_buff_size, paClipOff, NULL, NULL); if (audio->err != paNoError) HTS_error(0, "hts_engine: Failed to open your output audio device to play waveform.\n"); audio->err = Pa_StartStream(audio->stream); if (audio->err != paNoError) HTS_error(0, "hts_engine: Failed to start your output audio device to play waveform.\n"); audio->buff = (short *) HTS_calloc(max_buff_size, sizeof(short)); audio->buff_size = 0; }
/* HTS_freqt: frequency transformation */ static void HTS_freqt(HTS_Vocoder * v, const double *c1, const int m1, double *c2, const int m2, const double a) { int i, j; const double b = 1 - a * a; double *g; if (m2 > v->freqt_size) { if (v->freqt_buff != NULL) HTS_free(v->freqt_buff); v->freqt_buff = (double *) HTS_calloc(m2 + m2 + 2, sizeof(double)); v->freqt_size = m2; } g = v->freqt_buff + v->freqt_size + 1; for (i = 0; i < m2 + 1; i++) g[i] = 0.0; for (i = -m1; i <= 0; i++) { if (0 <= m2) g[0] = c1[-i] + a * (v->freqt_buff[0] = g[0]); if (1 <= m2) g[1] = b * v->freqt_buff[0] + a * (v->freqt_buff[1] = g[1]); for (j = 2; j <= m2; j++) g[j] = v->freqt_buff[j - 1] + a * ((v->freqt_buff[j] = g[j]) - g[j - 1]); } HTS_movem(g, c2, m2 + 1); }
/* HTS_ModelSet_load_parameter: load model */ void HTS_ModelSet_load_parameter(HTS_ModelSet * ms, FILE ** pdf_fp, FILE ** tree_fp, FILE ** win_fp, int stream_index, HTS_Boolean msd_flag, int window_size, int interpolation_size) { int i; /* check */ if (pdf_fp == NULL) HTS_error(1, "HTS_ModelSet_load_parameter: File for pdfs is not specified.\n"); if (tree_fp == NULL) HTS_error(1, "HTS_ModelSet_load_parameter: File for wins is not specified.\n"); if (win_fp == NULL) HTS_error(1, "HTS_ModelSet_load_parameter: File for wins is not specified.\n"); /* initialize */ if (!ms->stream) { ms->stream = (HTS_Stream *) HTS_calloc(ms->nstream, sizeof(HTS_Stream)); for (i = 0; i < ms->nstream; i++) HTS_Stream_initialize(&ms->stream[i]); } /* load */ HTS_Stream_load_pdf_and_tree(&ms->stream[stream_index], pdf_fp, tree_fp, msd_flag, interpolation_size); HTS_Stream_load_dynamic_window(&ms->stream[stream_index], win_fp, window_size); }
/* HTS_Stream_load_pdf_and_tree: load PDFs and trees */ static void HTS_Stream_load_pdf_and_tree(HTS_Stream * stream, FILE ** pdf_fp, FILE ** tree_fp, HTS_Boolean msd_flag, int interpolation_size) { int i; /* initialize */ stream->msd_flag = msd_flag; stream->interpolation_size = interpolation_size; stream->model = (HTS_Model *) HTS_calloc(interpolation_size, sizeof(HTS_Model)); /* load */ for (i = 0; i < stream->interpolation_size; i++) { if (!pdf_fp[i]) HTS_error(1, "HTS_Stream_load_pdf_and_tree: File for duration PDFs is not specified.\n"); if (!tree_fp[i]) HTS_error(1, "HTS_Stream_load_pdf_and_tree: File for duration trees is not specified.\n"); HTS_Model_initialize(&stream->model[i]); HTS_Model_load_tree(&stream->model[i], tree_fp[i]); HTS_Model_load_pdf(&stream->model[i], pdf_fp[i], stream->model[i].ntree, stream->msd_flag); } /* check */ for (i = 1; i < stream->interpolation_size; i++) if (stream->model[0].vector_length != stream->model[i].vector_length) HTS_error(1, "HTS_Stream_load_pdf_and_tree: Vector sizes of state output vectors are different in between given modelsets.\n"); /* set */ stream->vector_length = stream->model[0].vector_length; }
/* HTS_Tree_parse_pattern: parse pattern specified for each tree */ static void HTS_Tree_parse_pattern(HTS_Tree * tree, char *string) { char *left, *right; HTS_Pattern *pattern, *last_pattern; tree->head = NULL; last_pattern = NULL; /* parse tree pattern */ if ((left = strchr(string, '{')) != NULL) { /* pattern is specified */ string = left + 1; if (*string == '(') ++string; right = strrchr(string, '}'); if (string < right && *(right - 1) == ')') --right; *right = ','; /* parse pattern */ while ((left = strchr(string, ',')) != NULL) { pattern = (HTS_Pattern *) HTS_calloc(1, sizeof(HTS_Pattern)); if (tree->head) { last_pattern->next = pattern; } else { tree->head = pattern; } *left = '\0'; pattern->string = HTS_strdup(string); string = left + 1; pattern->next = NULL; last_pattern = pattern; } } }
/* HTS_b2en: calculate frame energy */ static double HTS_b2en(HTS_Vocoder * v, const double *b, const int m, const double a) { int i; double en = 0.0; double *cep; double *ir; if (v->spectrum2en_size < m) { if (v->spectrum2en_buff != NULL) HTS_free(v->spectrum2en_buff); v->spectrum2en_buff = (double *) HTS_calloc((m + 1) + 2 * IRLENG, sizeof(double)); v->spectrum2en_size = m; } cep = v->spectrum2en_buff + m + 1; ir = cep + IRLENG; HTS_b2mc(b, v->spectrum2en_buff, m, a); HTS_freqt(v, v->spectrum2en_buff, m, cep, IRLENG - 1, -a); HTS_c2ir(cep, IRLENG, ir, IRLENG); for (i = 0; i < IRLENG; i++) en += ir[i] * ir[i]; return (en); }
/* HTS_Question_load: Load questions from file */ static void HTS_Question_load(HTS_Question * question, FILE * fp) { char buff[HTS_MAXBUFLEN]; HTS_Pattern *pattern, *last_pattern; /* get question name */ HTS_get_pattern_token(fp, buff); question->string = HTS_strdup(buff); question->head = NULL; /* get pattern list */ HTS_get_pattern_token(fp, buff); last_pattern = NULL; if (strcmp(buff, "{") == 0) { while (1) { HTS_get_pattern_token(fp, buff); pattern = (HTS_Pattern *) HTS_calloc(1, sizeof(HTS_Pattern)); if (question->head) last_pattern->next = pattern; else /* first time */ question->head = pattern; pattern->string = HTS_strdup(buff); pattern->next = NULL; HTS_get_pattern_token(fp, buff); if (!strcmp(buff, "}")) break; last_pattern = pattern; } } }
/* HTS_gc2gc: generalized cepstral transformation */ static void HTS_gc2gc(HTS_Vocoder * v, double *c1, const int m1, const double g1, double *c2, const int m2, const double g2) { int i, min, k, mk; double ss1, ss2, cc; if (m1 > v->gc2gc_size) { if (v->gc2gc_buff != NULL) HTS_free(v->gc2gc_buff); v->gc2gc_buff = (double *) HTS_calloc(m1 + 1, sizeof(double)); v->gc2gc_size = m1; } HTS_movem(c1, v->gc2gc_buff, m1 + 1); c2[0] = v->gc2gc_buff[0]; for (i = 1; i <= m2; i++) { ss1 = ss2 = 0.0; min = m1 < i ? m1 : i - 1; for (k = 1; k <= min; k++) { mk = i - k; cc = v->gc2gc_buff[k] * c2[mk]; ss2 += k * cc; ss1 += mk * cc; } if (i <= m1) c2[i] = v->gc2gc_buff[i] + (g2 * ss2 - g1 * ss1) / i; else c2[i] = (g2 * ss2 - g1 * ss1) / i; } }
/* HTS_lsp2en: calculate frame energy */ static double HTS_lsp2en(HTS_Vocoder * v, double *lsp, size_t m, double alpha) { size_t i; double en = 0.0; double *buff; if (v->spectrum2en_size < m) { if (v->spectrum2en_buff != NULL) HTS_free(v->spectrum2en_buff); v->spectrum2en_buff = (double *) HTS_calloc(m + 1 + IRLENG, sizeof(double)); v->spectrum2en_size = m; } buff = v->spectrum2en_buff + m + 1; /* lsp2lpc */ HTS_lsp2lpc(v, lsp + 1, v->spectrum2en_buff, m); if (v->use_log_gain) v->spectrum2en_buff[0] = exp(lsp[0]); else v->spectrum2en_buff[0] = lsp[0]; /* mgc2mgc */ if (NORMFLG1) HTS_ignorm(v->spectrum2en_buff, v->spectrum2en_buff, m, v->gamma); else if (MULGFLG1) v->spectrum2en_buff[0] = (1.0 - v->spectrum2en_buff[0]) * ((double) v->stage); if (MULGFLG1) for (i = 1; i <= m; i++) v->spectrum2en_buff[i] *= -((double) v->stage); HTS_mgc2mgc(v, v->spectrum2en_buff, m, alpha, v->gamma, buff, IRLENG - 1, 0.0, 1); for (i = 0; i < IRLENG; i++) en += buff[i] * buff[i]; return en; }
/* HTS_Vocoder_postfilter_mcp: postfilter for MCP */ void HTS_Vocoder_postfilter_mcp(HTS_Vocoder *v, double *mcp, const int m, double alpha, double beta) { double e1, e2; int k; if (beta > 0.0 && m > 1) { if (v->postfilter_size < m) { if (v->postfilter_buff != NULL) HTS_free(v->postfilter_buff); v->postfilter_buff = (double *) HTS_calloc(m + 1, sizeof(double)); v->postfilter_size = m; } HTS_mc2b(mcp, v->postfilter_buff, m, alpha); e1 = HTS_b2en(v, v->postfilter_buff, m, alpha); v->postfilter_buff[1] -= beta * alpha * mcp[2]; for (k = 2; k <= m; k++) v->postfilter_buff[k] *= (1.0 + beta); e2 = HTS_b2en(v, v->postfilter_buff, m, alpha); v->postfilter_buff[0] += log(e1 / e2) / 2; HTS_b2mc(v->postfilter_buff, mcp, m, alpha); } }
/* HTS_Stream_load_pdf: load pdf */ static HTS_Boolean HTS_Stream_load_pdf(HTS_Stream * stream, HTS_File ** fp, int ntree, int interpolation_size) { int i; HTS_Boolean result = TRUE; /* initialize */ stream->interpolation_size = interpolation_size; stream->model = (HTS_Model *) HTS_calloc(interpolation_size, sizeof(HTS_Model)); /* load pdfs */ for (i = 0; i < stream->interpolation_size; i++) { HTS_Model_initialize(&stream->model[i]); if (HTS_Model_load_pdf(&stream->model[i], fp[i], ntree, &stream->msd_flag) == FALSE) result = FALSE; } if (result == FALSE) { HTS_Stream_clear(stream); return FALSE; } /* check */ for (i = 1; i < stream->interpolation_size; i++) { if (stream->model[0].vector_length != stream->model[1].vector_length) { HTS_error(1, "HTS_Stream_load_pdf: # of states are different in between given modelsets.\n"); HTS_Stream_clear(stream); return FALSE; } } /* set */ stream->vector_length = stream->model[0].vector_length; return TRUE; }
/* HTS_Vocoder_initialize: initialize vocoder */ void HTS_Vocoder_initialize(HTS_Vocoder * v, size_t m, size_t stage, HTS_Boolean use_log_gain, size_t rate, size_t fperiod) { /* set parameter */ v->is_first = TRUE; v->stage = stage; if (stage != 0) v->gamma = -1.0 / v->stage; else v->gamma = 0.0; v->use_log_gain = use_log_gain; v->fprd = fperiod; v->next = SEED; v->gauss = GAUSS; v->rate = rate; v->pitch_of_curr_point = 0.0; v->pitch_counter = 0.0; v->pitch_inc_per_point = 0.0; v->excite_ring_buff = NULL; v->excite_buff_size = 0; v->excite_buff_index = 0; v->sw = 0; v->x = 0x55555555; /* init buffer */ v->freqt_buff = NULL; v->freqt_size = 0; v->gc2gc_buff = NULL; v->gc2gc_size = 0; v->lsp2lpc_buff = NULL; v->lsp2lpc_size = 0; v->postfilter_buff = NULL; v->postfilter_size = 0; v->spectrum2en_buff = NULL; v->spectrum2en_size = 0; if (v->stage == 0) { /* for MCP */ v->c = (double *) HTS_calloc(m * (3 + PADEORDER) + 5 * PADEORDER + 6, sizeof(double)); v->cc = v->c + m + 1; v->cinc = v->cc + m + 1; v->d1 = v->cinc + m + 1; } else { /* for LSP */ v->c = (double *) HTS_calloc((m + 1) * (v->stage + 3), sizeof(double)); v->cc = v->c + m + 1; v->cinc = v->cc + m + 1; v->d1 = v->cinc + m + 1; } }
/* HTS_Label_load_from_strings: load label from strings */ void HTS_Label_load_from_strings(HTS_Label * label, size_t sampling_rate, size_t fperiod, char **lines, size_t num_lines) { char buff[HTS_MAXBUFLEN]; HTS_LabelString *lstring = NULL; size_t i; size_t data_index; double start, end; const double rate = (double) sampling_rate / ((double) fperiod * 1e+7); if (label->head || label->size != 0) { HTS_error(1, "HTS_Label_load_from_fp: label list is not initialized.\n"); return; } /* copy label */ for (i = 0; i < num_lines; i++) { if (!isgraph((int) lines[i][0])) break; label->size++; if (lstring) { lstring->next = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString)); lstring = lstring->next; } else { /* first time */ lstring = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString)); label->head = lstring; } data_index = 0; if (isdigit_string(lines[i])) { /* has frame infomation */ HTS_get_token_from_string(lines[i], &data_index, buff); start = atof(buff); HTS_get_token_from_string(lines[i], &data_index, buff); end = atof(buff); HTS_get_token_from_string(lines[i], &data_index, buff); lstring->name = HTS_strdup(buff); lstring->start = rate * start; lstring->end = rate * end; } else { lstring->start = -1.0; lstring->end = -1.0; lstring->name = HTS_strdup(lines[i]); } lstring->next = NULL; } HTS_Label_check_time(label); }
/* HTS_strdup: wrapper for strdup */ char *HTS_strdup(const char *string) { #ifdef FESTIVAL return (wstrdup(string)); #else char *buff = (char *) HTS_calloc(strlen(string) + 1, sizeof(char)); strcpy(buff, string); return buff; #endif /* FESTIVAL */ }
/* HTS_Engine_load: load HTS voices */ HTS_Boolean HTS_Engine_load(HTS_Engine * engine, char **voices, size_t num_voices) { size_t i, j; size_t nstream; double average_weight; const char *option, *find; /* reset engine */ HTS_Engine_clear(engine); /* load voices */ if (HTS_ModelSet_load(&engine->ms, voices, num_voices) != TRUE) { HTS_Engine_clear(engine); return FALSE; } nstream = HTS_ModelSet_get_nstream(&engine->ms); average_weight = 1.0 / num_voices; /* global */ engine->condition.sampling_frequency = HTS_ModelSet_get_sampling_frequency(&engine->ms); engine->condition.fperiod = HTS_ModelSet_get_fperiod(&engine->ms); engine->condition.msd_threshold = (double *) HTS_calloc(nstream, sizeof(double)); for (i = 0; i < nstream; i++) engine->condition.msd_threshold[i] = 0.5; engine->condition.gv_weight = (double *) HTS_calloc(nstream, sizeof(double)); for (i = 0; i < nstream; i++) engine->condition.gv_weight[i] = 1.0; /* spectrum */ option = HTS_ModelSet_get_option(&engine->ms, 0); find = strstr(option, "GAMMA="); if (find != NULL) engine->condition.stage = (size_t) atoi(&find[strlen("GAMMA=")]); find = strstr(option, "LN_GAIN="); if (find != NULL) engine->condition.use_log_gain = atoi(&find[strlen("LN_GAIN=")]) == 1 ? TRUE : FALSE; find = strstr(option, "ALPHA="); if (find != NULL) engine->condition.alpha = atof(&find[strlen("ALPHA=")]); /* interpolation weights */ engine->condition.duration_iw = (double *) HTS_calloc(num_voices, sizeof(double)); for (i = 0; i < num_voices; i++) engine->condition.duration_iw[i] = average_weight; engine->condition.parameter_iw = (double **) HTS_calloc(num_voices, sizeof(double *)); for (i = 0; i < num_voices; i++) { engine->condition.parameter_iw[i] = (double *) HTS_calloc(nstream, sizeof(double)); for (j = 0; j < nstream; j++) engine->condition.parameter_iw[i][j] = average_weight; } engine->condition.gv_iw = (double **) HTS_calloc(num_voices, sizeof(double *)); for (i = 0; i < num_voices; i++) { engine->condition.gv_iw[i] = (double *) HTS_calloc(nstream, sizeof(double)); for (j = 0; j < nstream; j++) engine->condition.gv_iw[i][j] = average_weight; } return TRUE; }
/* HTS_Engine_initialize: initialize engine */ void HTS_Engine_initialize(HTS_Engine * engine, int nstream) { int i; /* default value for control parameter */ engine->global.stage = 0; engine->global.use_log_gain = FALSE; engine->global.sampling_rate = 16000; engine->global.fperiod = 80; engine->global.alpha = 0.42; engine->global.beta = 0.0; engine->global.audio_buff_size = 0; engine->global.msd_threshold = (double *) HTS_calloc(nstream, sizeof(double)); for (i = 0; i < nstream; i++) engine->global.msd_threshold[i] = 0.5; /* interpolation weight */ engine->global.parameter_iw = (double **) HTS_calloc(nstream, sizeof(double *)); engine->global.gv_iw = (double **) HTS_calloc(nstream, sizeof(double *)); engine->global.duration_iw = NULL; for (i = 0; i < nstream; i++) engine->global.parameter_iw[i] = NULL; for (i = 0; i < nstream; i++) engine->global.gv_iw[i] = NULL; /* GV weight */ engine->global.gv_weight = (double *) HTS_calloc(nstream, sizeof(double)); for (i = 0; i < nstream; i++) engine->global.gv_weight[i] = 1.0; /* initialize model set */ HTS_ModelSet_initialize(&engine->ms, nstream); /* initialize label list */ HTS_Label_initialize(&engine->label); /* initialize state sequence set */ HTS_SStreamSet_initialize(&engine->sss); /* initialize pstream set */ HTS_PStreamSet_initialize(&engine->pss); /* initialize gstream set */ HTS_GStreamSet_initialize(&engine->gss); }
/* HTS_Vocoder_initialize: initialize vocoder */ void HTS_Vocoder_initialize(HTS_Vocoder * v, const int m, const int stage, HTS_Boolean use_log_gain, const int rate, const int fperiod) { /* set parameter */ v->stage = stage; if (stage != 0) v->gamma = -1.0 / v->stage; else v->gamma = 0.0; v->use_log_gain = use_log_gain; v->fprd = fperiod; v->iprd = IPERIOD; v->seed = SEED; v->next = SEED; v->gauss = GAUSS; v->rate = rate; v->p1 = -1.0; v->sw = 0; v->x = 0x55555555; /* init buffer */ v->freqt_buff = NULL; v->freqt_size = 0; v->gc2gc_buff = NULL; v->gc2gc_size = 0; v->lsp2lpc_buff = NULL; v->lsp2lpc_size = 0; v->postfilter_buff = NULL; v->postfilter_size = 0; v->spectrum2en_buff = NULL; v->spectrum2en_size = 0; if (v->stage == 0) { /* for MCP */ v->c = (double *) HTS_calloc(m * (3 + PADEORDER) + 5 * PADEORDER + 6, sizeof(double)); v->cc = v->c + m + 1; v->cinc = v->cc + m + 1; v->d1 = v->cinc + m + 1; } else { /* for LSP */ v->c = (double *) HTS_calloc((m + 1) * (v->stage + 3), sizeof(double)); v->cc = v->c + m + 1; v->cinc = v->cc + m + 1; v->d1 = v->cinc + m + 1; } v->pulse_list = (double *) HTS_calloc(PULSELISTSIZE, sizeof(double)); }
/* HTS_Engine_load_duration_from_fp: load duration pdfs, trees and number of state from file pointers */ void HTS_Engine_load_duration_from_fp(HTS_Engine * engine, FILE ** pdf_fp, FILE ** tree_fp, int interpolation_size) { int i; HTS_ModelSet_load_duration(&engine->ms, pdf_fp, tree_fp, interpolation_size); engine->global.duration_iw = (double *) HTS_calloc(interpolation_size, sizeof(double)); for (i = 0; i < interpolation_size; i++) engine->global.duration_iw[i] = 1.0 / interpolation_size; }
/* HTS_fopen_from_data: wrapper for fopen */ HTS_File *HTS_fopen_from_data(void *data, size_t size) { HTS_Data *d; HTS_File *f; if (data == NULL || size == 0) return NULL; d = (HTS_Data *) HTS_calloc(1, sizeof(HTS_Data)); d->data = (unsigned char *) HTS_calloc(size, sizeof(unsigned char)); d->size = size; d->index = 0; memcpy(d->data, data, size); f = (HTS_File *) HTS_calloc(1, sizeof(HTS_File)); f->type = HTS_DATA; f->pointer = (void *) d; return f; }
/* HTS_Label_load_from_string: load label from string */ void HTS_Label_load_from_string(HTS_Label * label, int sampling_rate, int fperiod, char *data) { char buff[HTS_MAXBUFLEN]; HTS_LabelString *lstring = NULL; int data_index = 0; /* data index */ double start, end; const double rate = (double) sampling_rate / ((double) fperiod * 1e+7); if (label->head || label->size != 0) HTS_error(1, "HTS_Label_load_from_fp: label list is not initialized.\n"); /* copy label */ while (HTS_get_token_from_string(data, &data_index, buff)) { if (!isgraph(buff[0])) break; label->size++; if (lstring) { lstring->next = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString)); lstring = lstring->next; } else { /* first time */ lstring = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString)); label->head = lstring; } if (isdigit_string(buff)) { /* has frame infomation */ start = atof(buff); HTS_get_token_from_string(data, &data_index, buff); end = atof(buff); HTS_get_token_from_string(data, &data_index, buff); lstring->start = rate * start; lstring->end = rate * end; } else { lstring->start = -1.0; lstring->end = -1.0; } lstring->next = NULL; lstring->name = HTS_strdup(buff); } HTS_Label_check_time(label); }
/* HTS_Label_load: load label */ static void HTS_Label_load(HTS_Label * label, size_t sampling_rate, size_t fperiod, HTS_File * fp) { char buff[HTS_MAXBUFLEN]; HTS_LabelString *lstring = NULL; double start, end; const double rate = (double) sampling_rate / ((double) fperiod * 1e+7); if (label->head || label->size != 0) { HTS_error(1, "HTS_Label_load_from_fp: label is not initialized.\n"); return; } /* parse label file */ while (HTS_get_token_from_fp(fp, buff)) { if (!isgraph((int) buff[0])) break; label->size++; if (lstring) { lstring->next = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString)); lstring = lstring->next; } else { /* first time */ lstring = (HTS_LabelString *) HTS_calloc(1, sizeof(HTS_LabelString)); label->head = lstring; } if (isdigit_string(buff)) { /* has frame infomation */ start = atof(buff); HTS_get_token_from_fp(fp, buff); end = atof(buff); HTS_get_token_from_fp(fp, buff); lstring->start = rate * start; lstring->end = rate * end; } else { lstring->start = -1.0; lstring->end = -1.0; } lstring->next = NULL; lstring->name = HTS_strdup(buff); } HTS_Label_check_time(label); }
/* HTS_Engine_load_duratin_from_fn: load duration pdfs, trees and number of state from file names */ void HTS_Engine_load_duration_from_fn(HTS_Engine * engine, char **pdf_fn, char **tree_fn, int interpolation_size) { int i; FILE **pdf_fp, **tree_fp; pdf_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *)); tree_fp = (FILE **) HTS_calloc(interpolation_size, sizeof(FILE *)); for (i = 0; i < interpolation_size; i++) { pdf_fp[i] = HTS_get_fp(pdf_fn[i], "rb"); tree_fp[i] = HTS_get_fp(tree_fn[i], "r"); } HTS_Engine_load_duration_from_fp(engine, pdf_fp, tree_fp, interpolation_size); for (i = 0; i < interpolation_size; i++) { fclose(pdf_fp[i]); fclose(tree_fp[i]); } HTS_free(pdf_fp); HTS_free(tree_fp); }
/* HTS_Engine_load_gv_from_fp: load GV pdfs and trees from file pointers */ void HTS_Engine_load_gv_from_fp(HTS_Engine * engine, FILE ** pdf_fp, FILE ** tree_fp, int stream_index, int interpolation_size) { int i; HTS_ModelSet_load_gv(&engine->ms, pdf_fp, tree_fp, stream_index, interpolation_size); engine->global.gv_iw[stream_index] = (double *) HTS_calloc(interpolation_size, sizeof(double)); for (i = 0; i < interpolation_size; i++) engine->global.gv_iw[stream_index][i] = 1.0 / interpolation_size; }
/* HTS_Tree_load: Load trees */ static void HTS_Tree_load(HTS_Tree * tree, FILE * fp, HTS_Question * question) { char buff[HTS_MAXBUFLEN]; HTS_Node *node, *last_node; HTS_get_pattern_token(fp, buff); node = (HTS_Node *) HTS_calloc(1, sizeof(HTS_Node)); node->index = 0; tree->root = last_node = node; if (strcmp(buff, "{") == 0) { while (HTS_get_pattern_token(fp, buff), strcmp(buff, "}") != 0) { node = HTS_Node_find(last_node, atoi(buff)); HTS_get_pattern_token(fp, buff); /* load question at this node */ node->quest = HTS_Question_find_question(question, buff); node->yes = (HTS_Node *) HTS_calloc(1, sizeof(HTS_Node)); node->no = (HTS_Node *) HTS_calloc(1, sizeof(HTS_Node)); HTS_get_pattern_token(fp, buff); if (HTS_is_num(buff)) node->no->index = atoi(buff); else node->no->pdf = HTS_name2num(buff); node->no->next = last_node; last_node = node->no; HTS_get_pattern_token(fp, buff); if (HTS_is_num(buff)) node->yes->index = atoi(buff); else node->yes->pdf = HTS_name2num(buff); node->yes->next = last_node; last_node = node->yes; } } else { node->pdf = HTS_name2num(buff); } }
/* HTS_fopen_from_fn: wrapper for fopen */ HTS_File *HTS_fopen_from_fn(const char *name, const char *opt) { HTS_File *fp = (HTS_File *) HTS_calloc(1, sizeof(HTS_File)); fp->type = HTS_FILE; fp->pointer = (void *) fopen(name, opt); if (fp->pointer == NULL) { HTS_error(0, "HTS_fopen: Cannot open %s.\n", name); HTS_free(fp); return NULL; } return fp; }