hled.c

Hidden Markov Toolkit (HTK) 3.2.1 HTK is a toolkit for use in research into automatic speech recogn

/* MergeOp: scan the current transcription and merge any consecutive
   sequence of items matching args[1,2,3,..] with arg[0], returns 
   number of merges performed */
int MergeOp(LabList *ll,int nArgs, LabId *args)
{
   LLink l,n,t;
   int count=0;
   
   if (trace&T_CMDX) TrOpEntry("ME(rge");
   nArgs--;
   for (l=ll->head->succ; l->succ!=NULL; l=l->succ)
      if((n=SeqMatch(l,nArgs,args+1))!=NULL) {
         ++count;
         l->labid = *args;
         for (t=l->succ; t!=n; t=t->succ) t->labid=NULL; /* Deleted */
         l->end = n->pred->end;
         l->succ = n;
         l->succ->pred = l;
      }
   if (trace&T_CMDX) TrOpExit(count);
   return count;
}

/* SortOp: sort the lablist into ascending order of start time */
void SortOp(LabList *rl)
{
   LLink i,j,sw,succ,pred;
   int count = 0;
   
   if (trace&T_CMDX) TrOpEntry("SO(rt");
   for (i=rl->head->succ; i->succ!=NULL; i=sw->succ) {
      sw = i;  /* find soonest label sw */
      for (j=i->succ; j->succ!=NULL; j=j->succ) {
         if (j->start<sw->start || (j->start==sw->start && j->end<sw->end))
            sw=j;
      }
      if (sw!=i) {  /* swap sw with first elem in scan list */
         ++count;
         pred = i->pred; succ = sw->succ;
         i->pred->succ = i->succ;      /* Delete i from list */
         i->succ->pred = i->pred;
         sw->pred->succ = sw->succ;    /* Delete sw from list */
         sw->succ->pred = sw->pred;
         i->succ = succ; i->pred=succ->pred;   /* Insert i */
         i->succ->pred = i->pred->succ = i;
         sw->pred = pred; sw->succ=pred->succ; /* Insert sw */
         sw->succ->pred = sw->pred->succ = sw;
      }  
   }
   if (trace&T_CMDX) TrOpExit(count);
}

/* IFillOp: fill inter-label gaps with arg1, return number added */
int IFillOp(LabList *ll,LabId *args)
{
   int count=0;
   LabId fId;
   LLink l,n;

   if (trace&T_CMDX) TrOpEntry("FG(fillgaps");
   if (ll->head->succ->succ != NULL) {
      fId = *args;
      for (l=ll->head->succ; l->succ->succ!=NULL; l=l->succ) {
         if ((l->succ->start - l->end) > minGap) {
            count++; 
            n = CreateLabel(&tempHeap,ll->maxAuxLab);
            n->labid = fId;
            n->start = l->end;
            n->end = l->succ->start;   
            n->succ = l->succ; n->pred = l;
            n->pred->succ = n; n->succ->pred = n;
         }
      }
   }
   if (trace&T_CMDX) TrOpExit(count);
   return count;
}

/* ISilOp: insert arg1 at start and arg2 at end */
int ISilOp(LabList *ll,LabId *args)
{
   LLink l,n;
   int count=0;

   if (trace&T_CMDX) TrOpEntry("IS(insert silence");
   if (ll->head->succ->succ != NULL) {
      count += 2;
      /* do start */
      l=ll->head;
      n = CreateLabel(&tempHeap,ll->maxAuxLab);
      n->labid = args[0];
      n->start = n->end = l->succ->start;
      n->succ = l->succ; n->pred = l;
      l->succ = n; n->succ->pred = n;
      /* do end */
      l=ll->tail->pred;
      n = CreateLabel(&tempHeap,ll->maxAuxLab);
      n->labid = args[1];
      n->start = n->end = l->end;
      n->succ = l->succ; n->pred = l;
      l->succ = n; n->succ->pred = n;
   }
   if (trace&T_CMDX) TrOpExit(count);
   return count;
}

/* ExpandOp: expand labels of form A_B_C_... A B C */
int ExpandOp(LabList *ll)
{
   int k,count=0,nparts;
   LLink l,n;
   LabId id;
   HTime partDur;

   if (trace&T_CMDX) TrOpEntry("EX(pand");
   for (l=ll->head->succ; l->succ!=NULL; l=l->succ) {
      id = l->labid;
      nparts = NumParts(id);
      if (nparts > 1 || dictFn != NULL) {
         partDur = (l->end - l->start) / nparts;
         l->labid = GetPart(id,1); /* Aux label stays with first */
         l->end = l->start+partDur;
         for (k=2; k<=nparts; k++){
            n = CreateLabel(&tempHeap,ll->maxAuxLab);
            n->labid = GetPart(id,k);
            n->start = l->end;
            n->end = n->start+partDur;          
            n->succ=l->succ;n->pred=l;
            l->succ=n;n->succ->pred=n;          
            l=n; count++;
         }
      }
   }
   if (trace&T_CMDX) TrOpExit(count);  
   return count;
}


/* MakeTriId:  concatenate args separated by - and +'s and return its id */
LabId MakeTriId(LabId l, LabId c, LabId r)
{
   char buf[MAXSTRLEN];
   LabId item;
   
   if ( l!= NULL){
      strcpy(buf,l->name); strcat(buf,"-");
      strcat(buf,c->name);
   } else
      strcpy(buf,c->name);
   if (r != NULL){
      strcat(buf,"+"); strcat(buf,r->name);
   }
   item = GetLabId(buf,TRUE);
   return item;
}

/* LeftTriCxt: return id of left context from idx */
LabId LeftTriCxt(LLink l)
{
   for (l=l->pred; l->pred; l=l->pred) if (!IsVBnd(l->labid)) break;
   return (l->pred!=NULL? l->labid: NULL);
}

/* RightTriCxt: return id of right context from idx */
LabId RightTriCxt(LLink l)
{
   for (l=l->succ; l->succ; l=l->succ) if (!IsVBnd(l->labid)) break;
   return (l->succ!=NULL? l->labid: NULL);
}

/* TriPhonise: convert phone labels in transcription t to either
      left, right or triphone (ie both) contexts */
int TriPhonise(LabList *ll,Boolean left, Boolean right, LabId stId, 
               LabId enId, char *cmd)
{
   int count=0;
   LabId leftId, centreId, rightId; 
   LLink l,t;
   LabList *tmp;
   
   if (trace&T_CMDX) TrOpEntry(cmd);
   tmp = CopyLabelList(&tempHeap, ll); 
   for (l=ll->head->succ,t=tmp->head->succ; l->succ!=NULL;
        l=l->succ,t=t->succ) {
      centreId = t->labid;
      if (l->pred->pred==NULL) {         /* First Label */
         leftId =left?stId:NULL;
         rightId = (right && stId != NULL)?RightTriCxt(t):NULL;
      }
      else if (t->succ->succ==NULL) {    /* Last Label */
         leftId = (left && enId != NULL)?LeftTriCxt(t):NULL;
         rightId = right?enId:NULL;
      }
      else {
         leftId =left?LeftTriCxt(t):NULL;
         rightId = right?RightTriCxt(t):NULL;
      }
      if (IsWBnd(leftId)  || IsWBnd(centreId)) leftId  = NULL;
      if (IsWBnd(rightId) || IsWBnd(centreId)) rightId = NULL;
      if ((l->labid = MakeTriId(leftId,centreId,rightId))!= centreId)
         ++count;
   }
   if (trace&T_CMDX) TrOpExit(count);  
   return count;
}

/* DoLCtxt: Left context command */
int DoLCtxt(LabList *ll,int nArgs,LabId *args)
{
   LabId x;
   
   x = nArgs==1?*args:NULL;
   return TriPhonise(ll,TRUE,FALSE,x,x,"LC(leftcontext");
}

/* DoRCtxt: Right context command */
int DoRCtxt(LabList *ll,int nArgs,LabId *args)
{
   LabId x;
   
   x = nArgs==1?*args:NULL;
   return TriPhonise(ll,FALSE,TRUE,x,x,"RC(rightcontext");
}

/* DoTCtxt: Left and Right context command */
int DoTCtxt(LabList *ll,int nArgs,LabId *args)
{
   LabId l,r;
   
   if (nArgs == 1)
      l = r = *args;
   else if (nArgs == 2){
      l = *args; r = *(args+1);
   } else
      l = r = NULL;
   return TriPhonise(ll,TRUE,TRUE,l,r,"TC(tricontext");
}

/* KillTimes: set all times to -1 */
void KillTimes(LabList *ll)
{
   LLink l;

   for (l=ll->head->succ; l->succ!=NULL; l=l->succ) {
      l->start = -1.0;
      l->end   = -1.0;
   }
}

/* ------------------ Multiple Level Handling -------------------- */

static int top=1;    /* virtual top level of current label list */

/* VSetLabelList: set top level to n */
void VSetLabelList(int n)
{
   top = n;
}

/* VGetLabelList: ensure attempts to get replacement top level 
                  are redirected */
LabList* VGetLabelList(Transcription *t, int n)
{
   if (n==top) n=1;
   else if (n==1) n=top;
   return GetLabelList(t, n);
}

/* SplitLevels: into separate LabLists (with pointers to parent) */
Transcription *SplitLevels(LabList *rl)
{
   Transcription *ltr;
   LabList *ll,*nl;
   LLink l,c;
   int lev;

   ltr = CreateTranscription(&tempHeap);
   nl=CopyLabelList(&tempHeap, rl);
   AddLabelList(nl, ltr);
   for (lev=1;lev<=rl->maxAuxLab;lev++) {
      ll=CreateLabelList(&tempHeap,1);
      AddLabelList(ll, ltr);
      for (l=nl->head->succ,c=NULL;l->succ!=NULL;l=l->succ) {
         if (l->auxLab[lev]!=NULL) {
            c=AddLabel(&tempHeap, ll, l->auxLab[lev], 
                       l->start, l->end, l->auxScore[lev]);
            c->auxLab[1]=(LabId) l;
            l->auxLab[lev]=NULL;
         }
         else if (c!=NULL)
            c->end=l->end;
      }
   }
   if (trace&T_SLEV) PrintTranscription(ltr,"Split levels");
   return ltr;
}

/* MergeLevels: merge separate LabLists back into levels */
LabList *MergeLevels(Transcription *ltr)
{
   LabList *ll;
   LLink l,c;
   int lev,idx;
   
   for (lev=idx=1;lev<ltr->numLists;lev++) {
      ll=GetLabelList(ltr,lev+1);
      if (ll->head->succ->succ==NULL)
         continue;
      for (c=ll->head->succ;c->succ!=NULL;c=c->succ) {
         l = (LLink) c->auxLab[1];
         l->auxLab[idx] = c->labid;
         l->auxScore[idx] = c->score;
      }
      idx++;
   }
   if (trace&T_SLEV) PrintTranscription(ltr,"Merged levels");
   return GetLabelList(ltr,1);
}

/* DeleteLevel: delete level lev from ltr */
void DeleteLevel(Transcription *ltr,int lev)
{
   LLink l,c;
   LabList *top,*ll;

   if (trace&T_CMDX) TrOpEntry("DL(deletelevel");
   if (lev==1) {
      /* Can't delete level 1 so do some swapping */

      if (ltr->numLists==1)
         HError(1231,"DeleteLevel: Cannot delete last levels");
      for (lev=2,ll=NULL;lev<=ltr->numLists;lev++) {
         ll=GetLabelList(ltr, lev);
         if (ll->head->succ->succ!=NULL)
            break;
         else if (lev==ltr->numLists)
            HError(1231,"DeleteLevel: Cannot delete final level");
      }

      top=GetLabelList(ltr, 1);

      /* First delete all labels in level 1 */

      top->head->succ=top->tail;
      top->tail->pred=top->head;

      /* Rebuild level lev using LLinks from level 1 */

      for (c=ll->head->succ;c->succ!=NULL;c=c->succ) {
         l = (LLink) c->auxLab[1];
         l->start = c->start;
         l->end = c->end;
         l->labid = c->labid; /* Will be redone later */
         l->score = c->score;

         l->succ = top->tail; l->pred = top->tail->pred;
         l->pred->succ = l->succ->pred = l;
      }
      /* Don't delete level because we will probably edit it */
      
      VSetLabelList(lev);
   }
   else
      ll=GetLabelList(ltr, lev);
   /* Delete level */

   ll->head->succ=ll->tail;
   ll->tail->pred=ll->head;
   if (trace&T_CMDX) TrOpExit(-1);
}

/* --------------------- Top Level Control -------------------- */

/* EditFile: Load label file and apply each script command to it. 
   Multiple alts within transcriptions are edited independently. */
void EditFile(char *labfn)
{
   ScriptItem *i;
   char outfn[255];
   int m,d,r,c,a,clev,nlev,list;
   Transcription *ct,*levs,*at;
   LabList *ll,*rl;
   LLink l;

   if (trace&T_TOP) {
      printf("Editing file: %s\n",labfn); fflush(stdout);
   }
   ct = LOpen(&tempHeap,labfn,ifmt);
   at = CreateTranscription(&tempHeap);
   triStrip = FALSE; /* reset to default value */
   
   a=c=m=d=r=0;
   for (list=1;list<=ct->numLists;list++) {
      rl = GetLabelList(ct, list);
      if (sortFirst) SortOp(rl);
      /* put each level as separate alt in levs */
      levs = SplitLevels(rl);
      nlev = levs->numLists; clev = 1;

      VSetLabelList(1); 
      ll = VGetLabelList(levs, clev);

      for (i = script; i != NULL; i = i->next) {
         if (i->cmd.op==SORT && nlev>1)
            HError(1231,"EditFile: Cannot perform SO on multilevel");
         else if ((i->cmd.op==EXPAND || i->cmd.op==IFILL || i->cmd.op==ISIL) 
                  && clev>1)
            HError(1231,"EditFile: Cannot perform EX/FG/IS on level>1");
         if (i->cmd.op != CHANGE || i==script) /* terminate any pending */
            ChangeOp(NULL, NULL);     /* sequence of CH(ange operations */
         if (i->cmd.op == TRIST)
            triStrip = !triStrip;
         if (ll!=NULL)
            switch (i->cmd.op) {
            case FIND:
               FindOp(ll,i->cmd.args); break;               
            case CHANGE:
               c += ChangeOp(ll,i->cmd.args); break;
            case REPLACE:
               r += ReplaceOp(ll,i->cmd.args); break;
            case MERGE:
               m += MergeOp(ll,i->cmd.nArgs,i->cmd.args); break;
            case LCTXT:
               c += DoLCtxt(ll,i->cmd.nArgs,i->cmd.args); break;
            case RCTXT:
               c += DoRCtxt(ll,i->cmd.nArgs,i->cmd.args); break;
            case TCTXT:
               c += DoTCtxt(ll,i->cmd.nArgs,i->cmd.args); break;
            case EDOP_DELETE:
               d += DeleteOp(ll,i->cmd.args); break;
            case DELLEV:
               if (i->cmd.nArgs==1)
                  DeleteLevel(levs,(int)i->cmd.args[0]->aux);
               else
                  DeleteLevel(levs,clev);
               break;
            case EXPAND:
               a += ExpandOp(ll); break;
            case IFILL:
               a += IFillOp(ll,i->cmd.args); break;
            case ISIL:
               a += ISilOp(ll,i->cmd.args); break;
            case SETLEV:
               clev=(int)i->cmd.args[0]->aux;
               if (clev>nlev) {
                  ll = NULL;
                  HError(-1231,"EditLevel: Level %d does not exist",clev);
               }else
                  ll = VGetLabelList(levs, clev);
               break;
            default: break;
            }
      }
      if (levSplit) {
         for (clev=1;clev<=nlev;clev++) {
            ll = GetLabelList(levs, clev);
            if (ll->head->succ->succ!=NULL) {
               ll->maxAuxLab = 0;      /* Don't want (dummy) auxlabs */
               ll = CopyLabelList(&tempHeap, ll);
               AddLabelList(ll, at);
            }
         }
      }else {
         ll = MergeLevels(levs);
         ll = CopyLabelList(&tempHeap, ll);
         AddLabelList(ll, at);
      }
   }
   MakeFN(labfn,newDir,newExt,outfn);
   if (newLabs != NULL)
      for (clev=1;clev<=at->numLists;clev++) {
         ll=GetLabelList(at, clev);
         for (l=ll->head->succ; l->succ!=NULL; l=l->succ)
            PutLab(l->labid);
      }
   if (noBounds)
      for (clev=1;clev<=at->numLists;clev++) {
         ll=GetLabelList(at, clev);
         KillTimes(ll);
      }
   if(LSave(outfn,at,ofmt)<SUCCESS)
      HError(1214,"EditFile: Cannot save file %s", outfn);
   if (trace&T_TOP) {
      printf("   %d adds; %d deletes; %d replaces; %d changes; %d merges\n",
             a,d,r,c,m);
      fflush(stdout);
   }
   if(trace & T_MEM) PrintAllHeapStats();
   ResetHeap(&tempHeap);
}


/* ------------------------------------------------------------ */
/*                         END:  HLEd.c                         */
/* ------------------------------------------------------------ */