/**
* Write header string as binary HMM file (ver. 2)
*
* @param fp [in] file pointer
* @param emp [in] TRUE if parameter embedded
* @param inv [in] TRUE if variances are inversed
* @param mpdfmacro [in] TRUE if some mixture pdfs are defined as macro
*/
static boolean
wt_header(FILE *fp, boolean emp, boolean inv, boolean mpdfmacro)
{
char buf[50];
char *p;
wrt_str(fp, binhmm_header_v2);
p = &(buf[0]);
if (emp) {
*p++ = '_';
*p++ = BINHMM_HEADER_V2_EMBEDPARA;
}
if (inv) {
*p++ = '_';
*p++ = BINHMM_HEADER_V2_VARINV;
}
if (mpdfmacro) {
*p++ = '_';
*p++ = BINHMM_HEADER_V2_MPDFMACRO;
}
*p = '\0';
wrt_str(fp, buf);
jlog("Stat: write_binhmm: written header: \"%s%s\"\n", binhmm_header_v2, buf);
return TRUE;
}
void display(char *map)
{
int start;
int nb_ply;
int nb_team;
char team_win;
start = 0;
while (42)
{
if ((nb_team = count_team(map)) == 1)
team_win = get_last_team(map);
nb_ply = count_player(map, 'a');
start = (nb_ply >= NB_PLAY ? 1 : start);
if (nb_ply < NB_PLAY && start == 0)
wrt_str("-{ You have to put more player for start the game. }-\n");
else
wrt_str("-{ The Game is running ! }-\n");
display_stat(map, nb_ply, nb_team);
display_map(map);
if (nb_ply == 1 && start == 1)
{
printf("The team %d Win !!!!\n", team_win - '0');
break;
}
}
}
/**
* @brief Write all mixture pdf data.
*
* The pointers of all mixture pdfs are first gathered,
* sorted by the address. Then the mixture pdfs are written
* by the sorted order. The pointers to the lower structure (variance etc.)
* in the data are written in a corresponding scholar id.
* The pointer index of this data will be used later to convert any pointer
* reference to a data into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_mpdf(FILE *fp, HTK_HMM_INFO *hmm)
{
HTK_HMM_PDF *m;
unsigned int idx;
mpdf_num = 0;
for(m=hmm->pdfstart;m;m=m->next) mpdf_num++;
mpdf_index = (HTK_HMM_PDF **)mymalloc(sizeof(HTK_HMM_PDF *) * mpdf_num);
idx = 0;
for(m=hmm->pdfstart;m;m=m->next) mpdf_index[idx++] = m;
qsort(mpdf_index, mpdf_num, sizeof(HTK_HMM_PDF *), (int (*)(const void *, const void *))qsort_mpdf_index);
wrt(fp, &mpdf_num, sizeof(unsigned int), 1);
for (idx = 0; idx < mpdf_num; idx++) {
m = mpdf_index[idx];
wrt_str(fp, m->name);
wrt(fp, &(m->stream_id), sizeof(short), 1);
if (wt_pdf_sub(fp, hmm, m) == FALSE) return FALSE;
}
jlog("Stat: write_binhmm: %d mixture PDF written\n", mpdf_num);
return TRUE;
}
/**
* @brief Write all mixture density data.
*
* The pointers of all mixture densities are first gathered,
* sorted by the address. Then the densities are written
* by the sorted order. The pointers to the lower structure (variance etc.)
* in the data are written in a corresponding scholar id.
* The pointer index of this data will be used later to convert any pointer
* reference to a density data into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_dens(FILE *fp, HTK_HMM_INFO *hmm)
{
HTK_HMM_Dens *d;
unsigned int idx;
unsigned int vid;
dens_num = hmm->totalmixnum;
dens_index = (HTK_HMM_Dens **)mymalloc(sizeof(HTK_HMM_Dens *) * dens_num);
idx = 0;
for(d = hmm->dnstart; d; d = d->next) dens_index[idx++] = d;
qsort(dens_index, dens_num, sizeof(HTK_HMM_Dens *), (int (*)(const void *, const void *))qsort_dens_index);
wrt(fp, &dens_num, sizeof(unsigned int), 1);
for (idx = 0; idx < dens_num; idx++) {
d = dens_index[idx];
wrt_str(fp, d->name);
wrt(fp, &(d->meanlen), sizeof(short), 1);
wrt(fp, d->mean, sizeof(VECT), d->meanlen);
vid = search_vid(d->var);
/* for debug */
if (d->var != vr_index[vid]) {
jlog("Error: write_binhmm: index not match!!!\n");
return FALSE;
}
wrt(fp, &vid, sizeof(unsigned int), 1);
wrt(fp, &(d->gconst), sizeof(LOGPROB), 1);
}
jlog("Stat: write_binhmm: %d gaussian densities written\n", dens_num);
return TRUE;
}
/**
* @brief Write all transition matrix data.
*
* The pointers of all transition matrixes are first gathered,
* sorted by the address. Then the transition matrix data are written
* by the sorted order. The index will be used later to convert any pointer
* reference to a transition matrix into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_trans(FILE *fp, HTK_HMM_INFO *hmm)
{
HTK_HMM_Trans *t;
unsigned int idx;
int i;
tr_num = 0;
for(t = hmm->trstart; t; t = t->next) tr_num++;
tr_index = (HTK_HMM_Trans **)mymalloc(sizeof(HTK_HMM_Trans *) * tr_num);
idx = 0;
for(t = hmm->trstart; t; t = t->next) tr_index[idx++] = t;
qsort(tr_index, tr_num, sizeof(HTK_HMM_Trans *), (int (*)(const void *, const void *))qsort_tr_index);
wrt(fp, &tr_num, sizeof(unsigned int), 1);
for (idx = 0; idx < tr_num; idx++) {
t = tr_index[idx];
wrt_str(fp, t->name);
wrt(fp, &(t->statenum), sizeof(short), 1);
for(i=0;i<t->statenum;i++) {
wrt(fp, t->a[i], sizeof(PROB), t->statenum);
}
}
jlog("Stat: write_binhmm: %d transition maxtix written\n", tr_num);
return TRUE;
}
/**
* @brief Write all state data.
*
* The pointers of all states are first gathered,
* sorted by the address. Then the state informations are written
* by the sorted order. The pointers to the lower structure (mixture etc.)
* in the data are written in a corresponding scholar id.
* The pointer index of this data will be used later to convert any pointer
* reference to a state data into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
* @param mpdf_macro [in] TRUE if mixture PDFs are already read as separated definitions
*/
static boolean
wt_state(FILE *fp, HTK_HMM_INFO *hmm, boolean mpdf_macro)
{
HTK_HMM_State *s;
unsigned int idx;
unsigned int mid;
unsigned int swid;
int m;
st_num = hmm->totalstatenum;
st_index = (HTK_HMM_State **)mymalloc(sizeof(HTK_HMM_State *) * st_num);
idx = 0;
for(s = hmm->ststart; s; s = s->next) st_index[idx++] = s;
qsort(st_index, st_num, sizeof(HTK_HMM_State *), (int (*)(const void *, const void *))qsort_st_index);
wrt(fp, &st_num, sizeof(unsigned int), 1);
for (idx = 0; idx < st_num; idx++) {
s = st_index[idx];
wrt_str(fp, s->name);
if (mpdf_macro) {
/* mpdf are already written, so write index */
for(m=0;m<s->nstream;m++) {
if (s->pdf[m] == NULL) {
mid = mpdf_num;
} else {
mid = search_mpdfid(s->pdf[m]);
if (s->pdf[m] != mpdf_index[mid]) {
jlog("Error: write_binhmm: index not match!!!\n");
return FALSE;
}
}
wrt(fp, &mid, sizeof(unsigned int), 1);
}
} else {
/* mpdf should be written here */
for(m=0;m<s->nstream;m++) {
/* stream_id will not be written */
if (wt_pdf_sub(fp, hmm, s->pdf[m]) == FALSE) return FALSE;
}
}
if (hmm->opt.stream_info.num > 1) {
/* write steam weight */
if (s->w == NULL) {
swid = streamweight_num;
} else {
swid = search_swid(s->w);
if (s->w != streamweight_index[swid]) {
jlog("Error: write_binhmm: index not match!!!\n");
return FALSE;
}
}
wrt(fp, &swid, sizeof(unsigned int), 1);
}
}
jlog("Stat: write_binhmm: %d states written\n", st_num);
return TRUE;
}
/**
* @brief Write all model data.
*
* The data of all models are written. The order is not important
* at this top level, since there are no reference to this data.
* The pointers to the lower structure (states, transitions, etc.)
* in the data are written by the corresponding scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_data(FILE *fp, HTK_HMM_INFO *hmm)
{
HTK_HMM_Data *d;
unsigned int md_num;
unsigned int sid, tid;
int i;
md_num = hmm->totalhmmnum;
wrt(fp, &(md_num), sizeof(unsigned int), 1);
for(d = hmm->start; d; d = d->next) {
wrt_str(fp, d->name);
wrt(fp, &(d->state_num), sizeof(short), 1);
for (i=0;i<d->state_num;i++) {
if (d->s[i] != NULL) {
sid = search_stid(d->s[i]);
/* for debug */
if (d->s[i] != st_index[sid]) {
jlog("Error: write_binhmm: index not match!!!\n");
return FALSE;
}
} else {
sid = hmm->totalstatenum + 1; /* error value */
}
wrt(fp, &sid, sizeof(unsigned int), 1);
}
tid = search_trid(d->tr);
/* for debug */
if (d->tr != tr_index[tid]) {
jlog("Error: write_binhmm: index not match!!!\n");
return FALSE;
}
wrt(fp, &tid, sizeof(unsigned int), 1);
}
jlog("Stat: write_binhmm: %d HMM model definition written\n", md_num);
return TRUE;
}
/**
* @brief Write all codebook data.
*
* The pointers of all codebook densities are first gathered,
* sorted by the address. Then the densities are written
* by the sorted order. The pointers to the lower structure (mixture etc.)
* in the data are written by the corresponding scholar id.
* The pointer index of this data will be used later to convert any pointer
* reference to a codebook into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_tmix(FILE *fp, HTK_HMM_INFO *hmm)
{
GCODEBOOK *tm;
unsigned int idx;
unsigned int did;
int i;
tm_num = hmm->codebooknum;
tm_index = (GCODEBOOK **)mymalloc(sizeof(GCODEBOOK *) * tm_num);
tm_idx = 0;
aptree_traverse_and_do(hmm->codebook_root, tmix_list_callback);
qsort(tm_index, tm_num, sizeof(GCODEBOOK *), (int (*)(const void *, const void *))qsort_tm_index);
wrt(fp, &tm_num, sizeof(unsigned int), 1);
for (idx = 0; idx < tm_num; idx++) {
tm = tm_index[idx];
wrt_str(fp, tm->name);
wrt(fp, &(tm->num), sizeof(int), 1);
for(i=0;i<tm->num;i++) {
if (tm->d[i] == NULL) {
did = dens_num;
} else {
did = search_did(tm->d[i]);
/* for debug */
if (tm->d[i] != dens_index[did]) {
jlog("Error: write_binhmm: index not match!!!\n");
return FALSE;
}
}
wrt(fp, &did, sizeof(unsigned int), 1);
}
}
jlog("Stat: write_binhmm: %d tied-mixture codebooks written\n", tm_num);
return TRUE;
}
/**
* @brief Write all stream weight data.
*
* The pointers of all stream weights are first gathered,
* sorted by the address. Then the stream weights are written
* by the sorted order. The pointers to the lower structure (variance etc.)
* in the data are written in a corresponding scholar id.
* The pointer index of this data will be used later to convert any pointer
* reference to a data into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_streamweight(FILE *fp, HTK_HMM_INFO *hmm)
{
HTK_HMM_StreamWeight *sw;
unsigned int idx;
streamweight_num = 0;
for(sw=hmm->swstart;sw;sw=sw->next) streamweight_num++;
streamweight_index = (HTK_HMM_StreamWeight **)mymalloc(sizeof(HTK_HMM_StreamWeight *) * streamweight_num);
idx = 0;
for(sw = hmm->swstart; sw; sw = sw->next) streamweight_index[idx++] = sw;
qsort(streamweight_index, streamweight_num, sizeof(HTK_HMM_StreamWeight *), (int (*)(const void *, const void *))qsort_streamweight_index);
wrt(fp, &streamweight_num, sizeof(unsigned int), 1);
for (idx = 0; idx < streamweight_num; idx++) {
sw = streamweight_index[idx];
wrt_str(fp, sw->name);
wrt(fp, &(sw->len), sizeof(short), 1);
wrt(fp, sw->weight, sizeof(VECT), sw->len);
}
jlog("Stat: write_binhmm: %d stream weights written\n", streamweight_num);
return TRUE;
}
/**
* @brief Write all variance data.
*
* The pointers of all variance vectors are first gathered,
* sorted by the address. Then the variance vectors are written
* by the sorted order. The index will be used later to convert any pointer
* reference to a variance vector into scholar id.
*
* @param fp [in] file pointer
* @param hmm [in] writing %HMM definition data
*/
static boolean
wt_var(FILE *fp, HTK_HMM_INFO *hmm)
{
HTK_HMM_Var *v;
unsigned int idx;
vr_num = 0;
for(v = hmm->vrstart; v; v = v->next) vr_num++;
vr_index = (HTK_HMM_Var **)mymalloc(sizeof(HTK_HMM_Var *) * vr_num);
idx = 0;
for(v = hmm->vrstart; v; v = v->next) vr_index[idx++] = v;
qsort(vr_index, vr_num, sizeof(HTK_HMM_Var *), (int (*)(const void *, const void *))qsort_vr_index);
wrt(fp, &vr_num, sizeof(unsigned int), 1);
for (idx = 0; idx < vr_num; idx++) {
v = vr_index[idx];
wrt_str(fp, v->name);
wrt(fp, &(v->len), sizeof(short), 1);
wrt(fp, v->vec, sizeof(VECT), v->len);
}
jlog("Stat: write_binhmm: %d variance written\n", vr_num);
return TRUE;
}
