/* HTS_Stream_clear: free stream */
static void HTS_Stream_clear(HTS_Stream * stream)
{
int i;
if (stream->model) {
for (i = 0; i < stream->interpolation_size; i++)
HTS_Model_clear(&stream->model[i]);
HTS_free(stream->model);
}
HTS_Window_clear(&stream->window);
HTS_Stream_initialize(stream);
}
/* HTS_ModelSet_clear: free model set */
void HTS_ModelSet_clear(HTS_ModelSet * ms)
{
int i;
HTS_Stream_clear(&ms->duration);
if (ms->stream) {
for (i = 0; i < ms->nstream; i++)
HTS_Stream_clear(&ms->stream[i]);
HTS_free(ms->stream);
}
if (ms->gv) {
for (i = 0; i < ms->nstream; i++)
HTS_Stream_clear(&ms->gv[i]);
HTS_free(ms->gv);
}
HTS_Model_clear(&ms->gv_switch);
HTS_ModelSet_initialize(ms, -1);
}
/* HTS_Model_load_tree: load trees */
static HTS_Boolean HTS_Model_load_tree(HTS_Model * model, HTS_File * fp)
{
char buff[HTS_MAXBUFLEN];
HTS_Question *question, *last_question;
HTS_Tree *tree, *last_tree;
int state;
/* check */
if (model == NULL || fp == NULL) {
HTS_error(1, "HTS_Model_load_tree: File for trees is not specified.\n");
return FALSE;
}
model->ntree = 0;
last_question = NULL;
last_tree = NULL;
while (!HTS_feof(fp)) {
HTS_get_pattern_token(fp, buff);
/* parse questions */
if (strcmp(buff, "QS") == 0) {
question = (HTS_Question *) HTS_calloc(1, sizeof(HTS_Question));
if (HTS_Question_load(question, fp) == FALSE) {
free(question);
HTS_Model_clear(model);
return FALSE;
}
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);
if (HTS_Tree_load(tree, fp, model->question) == FALSE) {
free(tree);
HTS_Model_clear(model);
return FALSE;
}
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");
return FALSE;
}
return TRUE;
}
/* HTS_Model_load_pdf: load pdfs */
static HTS_Boolean HTS_Model_load_pdf(HTS_Model * model, HTS_File * fp, int ntree, HTS_Boolean * msd_flag)
{
int i, j, k, l, m;
float temp;
int ssize;
HTS_Boolean result = TRUE;
/* check */
if (model == NULL || fp == NULL || ntree <= 0) {
HTS_error(1, "HTS_Model_load_pdf: File for pdfs is not specified.\n");
return FALSE;
}
/* load pdf */
model->ntree = ntree;
/* read MSD flag */
HTS_fread_big_endian(&i, sizeof(int), 1, fp);
*msd_flag = i;
if ((*msd_flag != FALSE) && (*msd_flag != TRUE)) {
HTS_error(1, "HTS_Model_load_pdf: Failed to load header of pdfs.\n");
HTS_Model_initialize(model);
return FALSE;
}
/* read stream size */
HTS_fread_big_endian(&ssize, sizeof(int), 1, fp);
if (ssize < 1) {
HTS_error(1, "HTS_Model_load_pdf: Failed to load header of pdfs.\n");
HTS_Model_initialize(model);
return FALSE;
}
/* read vector size */
HTS_fread_big_endian(&model->vector_length, sizeof(int), 1, fp);
if (model->vector_length <= 0) {
HTS_error(1, "HTS_Model_load_pdf: # of HMM states %d should be positive.\n", model->vector_length);
HTS_Model_initialize(model);
return FALSE;
}
model->npdf = (int *) HTS_calloc(ntree, sizeof(int));
model->npdf -= 2;
/* read the number of pdfs */
if (HTS_fread_big_endian(&model->npdf[2], sizeof(int), ntree, fp) != ntree)
result = FALSE;
for (i = 2; i <= ntree + 1; i++)
if (model->npdf[i] <= 0) {
HTS_error(1, "HTS_Model_load_pdf: # of pdfs at %d-th state should be positive.\n", i);
result = FALSE;
break;
}
if (result == FALSE) {
model->npdf += 2;
free(model->npdf);
HTS_Model_initialize(model);
return FALSE;
}
model->pdf = (double ***) HTS_calloc(ntree, sizeof(double **));
model->pdf -= 2;
/* read means and variances */
if (*msd_flag) { /* for MSD */
for (j = 2; j <= ntree + 1; j++) {
model->pdf[j] = (double **) HTS_calloc(model->npdf[j], sizeof(double *));
model->pdf[j]--;
for (k = 1; k <= model->npdf[j]; k++) {
model->pdf[j][k] = (double *) HTS_calloc(2 * model->vector_length + 1, sizeof(double));
for (l = 0; l < ssize; l++) {
for (m = 0; m < model->vector_length / ssize; m++) {
if (HTS_fread_big_endian(&temp, sizeof(float), 1, fp) != 1)
result = FALSE;
model->pdf[j][k][l * model->vector_length / ssize + m] = (double) temp;
if (HTS_fread_big_endian(&temp, sizeof(float), 1, fp) != 1)
result = FALSE;
model->pdf[j][k][l * model->vector_length / ssize + m + model->vector_length] = (double) temp;
}
if (HTS_fread_big_endian(&temp, sizeof(float), 1, fp) != 1)
result = FALSE;
if (l == 0) {
if (temp < 0.0 || temp > 1.0) {
HTS_error(1, "HTS_Model_load_pdf: MSD weight should be within 0.0 to 1.0.\n");
result = FALSE;
}
model->pdf[j][k][2 * model->vector_length] = (double) temp;
}
if (HTS_fread_big_endian(&temp, sizeof(float), 1, fp) != 1)
result = FALSE;
}
}
}
} else { /* for non MSD */
for (j = 2; j <= ntree + 1; j++) {
model->pdf[j] = (double **) HTS_calloc(model->npdf[j], sizeof(double *));
model->pdf[j]--;
for (k = 1; k <= model->npdf[j]; k++) {
model->pdf[j][k] = (double *) HTS_calloc(2 * model->vector_length, sizeof(double));
for (l = 0; l < model->vector_length; l++) {
if (HTS_fread_big_endian(&temp, sizeof(float), 1, fp) != 1)
result = FALSE;
model->pdf[j][k][l] = (double) temp;
if (HTS_fread_big_endian(&temp, sizeof(float), 1, fp) != 1)
result = FALSE;
model->pdf[j][k][l + model->vector_length] = (double) temp;
}
}
}
}
if (result == FALSE) {
HTS_Model_clear(model);
return FALSE;
}
return TRUE;
}
