libsent/src/hmminfo/cdset.c

Go to the documentation of this file.

/*
 * Copyright (c) 1991-2006 Kawahara Lab., Kyoto University
 * Copyright (c) 2000-2005 Shikano Lab., Nara Institute of Science and Technology
 * Copyright (c) 2005-2006 Julius project team, Nagoya Institute of Technology
 * All rights reserved
 */

#include <sent/stddefs.h>
#include <sent/htk_param.h>
#include <sent/htk_hmm.h>



#define CD_STATE_SET_STEP 10    


static void
cdset_init(HTK_HMM_INFO *hmminfo)
{
  hmminfo->cdset_info.cdtree = NULL;
}

static CD_Set *
cdset_new()
{
  return((CD_Set *)mymalloc(sizeof(CD_Set)));
}

CD_Set *
cdset_lookup(HTK_HMM_INFO *hmminfo, char *cdstr)
{
  CD_Set *cd;
  cd = aptree_search_data(cdstr, hmminfo->cdset_info.cdtree);
  if (strmatch(cdstr, cd->name)) {
    return cd;
  } else {
    return NULL;
  }
}

CD_Set *
lcdset_lookup_by_hmmname(HTK_HMM_INFO *hmminfo, char *hmmname)
{
  static char buf[MAX_HMMNAME_LEN];

  return(cdset_lookup(hmminfo, leftcenter_name(hmmname, buf)));
}

CD_Set *
rcdset_lookup_by_hmmname(HTK_HMM_INFO *hmminfo, char *hmmname)
{
  static char buf[MAX_HMMNAME_LEN];

  return(cdset_lookup(hmminfo, rightcenter_name(hmmname, buf)));
}


static void
put_cdset(void *ptr)
{
  int i;
  CD_Set *a;

  a = ptr;
  printf("name: %s\n", a->name);
  /* printf("state_num: %d\n", a->state_num); */
  for(i=0;i<a->state_num;i++) {
    if (a->stateset[i].num == 0) {
      printf("\t[state %d]  not exist\n", i);
    } else {
      printf("\t[state %d]  %d variants\n", i, a->stateset[i].num);
    }
    /*
      for(j=0;j<a->stateset[i].num;j++) {
        put_htk_state(a->stateset[i].s[j]);
      }
    */
  }
}

void
put_all_cdinfo(HTK_HMM_INFO *hmminfo)
{
  aptree_traverse_and_do(hmminfo->cdset_info.cdtree, put_cdset);
}


boolean
regist_cdset(APATNODE **root, HTK_HMM_Data *d, char *cdname)
{
  boolean need_new;
  CD_State_Set *tmp;
  CD_Set *lset = NULL, *lmatch = NULL;
  int j,n;
  boolean changed = FALSE;

  if (strlen(cdname) >= MAX_HMMNAME_LEN) {
    j_error("Error: HMM name exceeds limit (%d): %s!\n", MAX_HMMNAME_LEN, cdname);
  }
  
  /* check if the cdset already exist */
  need_new = TRUE;
  if (*root != NULL) {
    lmatch = aptree_search_data(cdname, *root);
    if (strmatch(lmatch->name, cdname)) {
      /* exist, add to it later */
      lset = lmatch;
      need_new = FALSE;
      /* if the state num is larger than allocated, expand the lset */
      if (d->state_num > lset->state_num) {
        lset->stateset = (CD_State_Set *)myrealloc(lset->stateset, sizeof(CD_State_Set) * d->state_num);
        /* 0 1 ... (lset->state_num-1) */
        /* N A ... N                   */
        /* 0 1 ...                     ... (d->state_num-1) */
        /* N A ... A ..................... N                */
        /* malloc new area to expanded state (N to A above) */
        for(j = lset->state_num - 1; j < d->state_num - 1; j++) {
          lset->stateset[j].maxnum = CD_STATE_SET_STEP;
          lset->stateset[j].s = (HTK_HMM_State **)mymalloc(sizeof(HTK_HMM_State *) * lset->stateset[j].maxnum);
          lset->stateset[j].num = 0;
        }
        lset->stateset[d->state_num-1].s = NULL;
        lset->stateset[d->state_num-1].num = 0;
        lset->stateset[d->state_num-1].maxnum = 0;
        
        lset->state_num = d->state_num;

        /* update transition table */
        lset->tr = d->tr;

        changed = TRUE;
      }
    }
  }

  if (need_new) {
    /* allocate as new with blank data */
    lset = cdset_new();
    lset->name = strdup(cdname);
    lset->state_num = d->state_num;
    lset->stateset = (CD_State_Set *)mymalloc(sizeof(CD_State_Set) * lset->state_num);
    /* assume first and last state has no outprob */
    lset->stateset[0].s = lset->stateset[lset->state_num-1].s = NULL;
    lset->stateset[0].num = lset->stateset[lset->state_num-1].num = 0;
    lset->stateset[0].maxnum = lset->stateset[lset->state_num-1].maxnum = 0;
    for(j=1;j<lset->state_num-1; j++) {
      /* pre-allocate only the first step */
      lset->stateset[j].maxnum = CD_STATE_SET_STEP;
      lset->stateset[j].s = (HTK_HMM_State **)mymalloc(sizeof(HTK_HMM_State *) * lset->stateset[j].maxnum);
      lset->stateset[j].num = 0;
    }
    /* assign transition table of first found %HMM (ad-hoc?) */
    lset->tr = d->tr;
    /* add to search index tree */
    if (*root == NULL) {
      *root = aptree_make_root_node(lset);
    } else {
      aptree_add_entry(lset->name, lset, lmatch->name, root);
    }

    changed = TRUE;
  }
    
  /*j_printerr("add to \"%s\"\n", lset->name);*/
  /* register each HMM states to the lcdset */
  for (j=1;j<d->state_num-1;j++) {
    tmp = &(lset->stateset[j]);
    /* check if the state has already registered */
    for(n = 0; n < tmp->num ; n++) {
      if (tmp->s[n] == d->s[j]) { /* compare by pointer */
        /*j_printerr("\tstate %d has same\n", n);*/
        break;
      }
    }
    if (n < tmp->num ) continue;        /* same state found, cancel regist. */
    
    /* expand storage area if necessary */
    if (tmp->num >= tmp->maxnum) {
      tmp->maxnum += CD_STATE_SET_STEP;
      tmp->s = (HTK_HMM_State **)myrealloc(tmp->s, sizeof(HTK_HMM_State *) * tmp->maxnum);
    }
    
    tmp->s[tmp->num] = d->s[j];
    tmp->num++;

    changed = TRUE;
  }

  return(changed);
}

boolean
remove_cdset(HTK_HMM_INFO *hmminfo, char *cdname)
{
  CD_Set *lmatch;
  
  if (hmminfo->cdset_info.cdtree == NULL) return TRUE;

  lmatch = aptree_search_data(cdname, hmminfo->cdset_info.cdtree);
  if (strmatch(lmatch->name, cdname)) {
    printf("[%s] found\n", lmatch->name);
    /* found */
    /*
    for(j=1;j<lmatch->state_num-1;j++) {
      free(lmatch->stateset[j].s);
    }
    free(lmatch->stateset);
    */
    aptree_remove_entry(cdname, &(hmminfo->cdset_info.cdtree));
  } else {
    return FALSE;
  }
  return TRUE;
}
  

boolean
make_cdset(HTK_HMM_INFO *hmminfo)
{
  HMM_Logical *lg;
  static char buf[MAX_HMMNAME_LEN];

  cdset_init(hmminfo);
  /* make cdset name from logical HMM name */
  /* left-context set: "a-k" for /a-k+i/, /a-k+o/, ...
     for 1st pass (word end) */
  for(lg = hmminfo->lgstart; lg; lg = lg->next) {
    if (lg->is_pseudo) continue;
    regist_cdset(&(hmminfo->cdset_info.cdtree), lg->body.defined, leftcenter_name(lg->name, buf));
  }
  /* right-context set: "a+o" for /b-a+o/, /t-a+o/, ...
     for 2nd pass (word beginning) */
  for(lg = hmminfo->lgstart; lg; lg = lg->next) {
    if (lg->is_pseudo) continue;
    regist_cdset(&(hmminfo->cdset_info.cdtree), lg->body.defined, rightcenter_name(lg->name, buf));
  }
  /* both-context set: "a" for all triphone with same base phone "a"
     for 1st pass (1 phoneme word, with no previous word hypo.) */
  for(lg = hmminfo->lgstart; lg; lg = lg->next) {
    if (lg->is_pseudo) continue;
    regist_cdset(&(hmminfo->cdset_info.cdtree), lg->body.defined, center_name(lg->name, buf));
  }

  /* now that cdset is completely built */
  
  return(TRUE);
}

static void
callback_free_lcdset_content(void *arg)
{
  CD_Set *d;
  int j;

  d = arg;
  for(j=0;j<d->state_num;j++) {
    if (d->stateset[j].s != NULL) free(d->stateset[j].s);
  }
  free(d->stateset);
  free(d->name);
  free(d);
}

void
free_cdset(APATNODE **root)
{
  if (*root != NULL) {
    aptree_traverse_and_do(*root, callback_free_lcdset_content);
    free_aptree(*root);
    *root = NULL;
  }
}

---