hnet.c

该压缩包为最新版htk的源代码,htk是现在比较流行的语音处理软件,请有兴趣的朋友下载使用

static int ReadAlign(Lattice *lat,LArc *la,char *buf)
{
   LAlign *lal;
   char *p,*str;
   int i,n,c;

   for(n=-1,p=buf;*p;p++) if (*p==':') n++;
   if (n<1) return(0);

   la->lAlign=(LAlign *) New(lat->heap,sizeof(LAlign)*n);
   
   for(i=0,lal=la->lAlign,p=buf;i<n;i++,lal++) {
      if (*p!=':')
         HError(8250,"ReadAlign: ':' Expected at start of field %d in %s",
                i,buf);
      for (str=++p;*p!=':' && *p!=',';p++)
         if (*p==0) HError(8250,"ReadAlign: Unexpected end of field %s",buf);
      c=*p;*p=0;lal->label=GetLabId(str,TRUE);
      if ((str=strchr(lal->label->name,'['))!=NULL)
         lal->state=atoi(str+1);
      else lal->state=-1;
      *p=c;
      if (*p==',') {
         str=p+1;
         lal->dur=strtod(str,&p);
         if (p==str || (*p!=':' && *p!=',')) 
            HError(8250,"ReadAlign: Cannot read duration %d from field %s",
                   i,buf);
      }
      if (*p==',') {
         str=p+1;
         lal->like=strtod(str,&p);
         if (p==str || *p!=':') 
            HError(8250,"ReadAlign: Cannot read like %d from field %s",i,buf);
      }
   }
   return(n);
}

/* ReadOneLattice: Read (one level) of lattice from file */
Lattice *ReadOneLattice(Source *src, MemHeap *heap, Vocab *voc, 
                               Boolean shortArc, Boolean add2Dict)
{
   int i,s,e,n,v=0,nn,na;
   Lattice *lat;
   LNode *ln;
   LArc *la;
   Word wordId;
   double time,aclike,lmlike;
   double prlike;
   char nbuf[132],vbuf[132],*ptr,ntype,del;
#define DBUFLEN 4096
   char dbuf[DBUFLEN];
   double lmscl=1.0, lmpen=0.0, acscl=1.0, prscl=1.0;
   float logbase = 1.0, tscale = 1.0;

   char *uttstr,*lmnstr,*vocstr,*hmmstr,*sublatstr,*tag;
   SubLatDef *subLatId = NULL;

   lat = (Lattice *) New(heap,sizeof(Lattice));
   lat->heap=heap; lat->subLatId=NULL; lat->chain=NULL;
   lat->voc=voc; lat->refList=NULL; lat->subList=NULL;

   /* Initialise default header values */
   nn=0;na=0; uttstr=lmnstr=vocstr=hmmstr=sublatstr=NULL;
   /* Process lattice header */
   while((ptr=GetNextFieldName(nbuf,&del,src))) {
      if (nbuf[0]=='\n') {
         if (na != 0 && nn != 0) break;
      }
      else if (strlen(ptr)==1) {
         ntype=*ptr;
         switch(ntype) {
         case 'N':
            nn=GetIntField('N',del,vbuf,src);
            break;
         case 'L':
            na=GetIntField('L',del,vbuf,src);
            break;
         default:
            GetFieldValue(0,src,0);
            break;
         }
      }
      else {
         if (!strcmp(ptr,"UTTERANCE"))
            GetFieldValue(vbuf,src,0),uttstr=CopyString(heap,vbuf);
         else if (!strcmp(ptr,"SUBLAT"))
            GetFieldValue(vbuf,src,0),sublatstr=CopyString(heap,vbuf);
         else if (!strcmp(ptr,"vocab"))
            GetFieldValue(vbuf,src,0),vocstr=CopyString(heap,vbuf);
         else if (!strcmp(ptr,"hmms"))
            GetFieldValue(vbuf,src,0),hmmstr=CopyString(heap,vbuf);
         else if (!strcmp(ptr,"lmname"))
            GetFieldValue(vbuf,src,0),lmnstr=CopyString(heap,vbuf);
         else if (!strcmp(ptr,"wdpenalty"))
            lmpen=GetFltField('p',del,vbuf,src);
         else if (!strcmp(ptr,"lmscale"))
            lmscl=GetFltField('s',del,vbuf,src);
         else if (!strcmp(ptr,"prscale"))
            prscl=GetFltField('s',del,vbuf,src);
         else if (!strcmp(ptr,"acscale"))
            acscl=GetFltField('a',del,vbuf,src);
         else if (!strcmp(ptr,"base"))
            logbase=GetFltField('b',del,vbuf,src);
         else if (!strcmp(ptr,"tscale"))
            tscale=GetFltField('t',del,vbuf,src);
         else
            GetFieldValue(NULL,src,0);
      }
   }

   if(ptr == NULL){
      /* generic memory clearing routine */
      Dispose(heap, lat);
      HRError(8250,"ReadLattice: Premature end of lattice file before header");
      return(NULL);
   }

   /* Initialise lattice based on header information */
   lat->nn=nn;
   lat->na=na;
   lat->utterance=uttstr;lat->vocab=vocstr;lat->hmms=hmmstr;
   lat->net=lmnstr;lat->lmscale=lmscl;lat->wdpenalty=lmpen;
   lat->acscale = acscl;
   lat->logbase = logbase;
   lat->tscale = tscale;
   lat->framedur=0;
   lat->prscale=prscl;

   if (logbase < 0.0)
      HError (8251, "ReadLattice: Illegal log base in lattice");

   /* Set format to indicate type and default word label position */
   lat->format=(shortArc?HLAT_SHARC|HLAT_ALABS:HLAT_ALABS);

   /* Presence of SUBLAT=id string indicates more to come */
   lat->subList=NULL; lat->chain=NULL;
   if (sublatstr!=NULL) lat->subLatId = GetLabId(sublatstr,TRUE);
   else lat->subLatId = NULL;

   /* Allocate and initiailise nodes/arcs */
   lat->lnodes=(LNode *) New(heap, sizeof(LNode)*nn);
   if (shortArc) 
      lat->larcs=(LArc *) New(heap, sizeof(LArc_S)*na);
   else 
      lat->larcs=(LArc *) New(heap, sizeof(LArc)*na);

   for(i=0, ln=lat->lnodes; i<nn; i++, ln++) {
      ln->hook=NULL;
      ln->pred=NULL;
      ln->foll=NULL;
      ln->score=0.0;
   }
   for(i=0, la=lat->larcs; i<na; i++, la=NextLArc(lat,la)) {
      la->lmlike=0.0;
      la->start=la->end=NNODE;
      la->farc=la->parc=NARC;
   }
   if (!shortArc)
      for(i=0, la=lat->larcs; i<na; i++, la=NextLArc(lat,la)) {
         la->aclike=la->prlike=la->score=0.0;
         la->nAlign=0;
         la->lAlign=NULL;
      }
   
   do {
      if ((ptr=GetNextFieldName(nbuf,&del,src)) == NULL)
         break;
      /* Recognised line types have only one character names */
      if (strlen(ptr)==1) 
         ntype=*ptr;
      else 
         ntype=0;
      if (ntype == '.') {
         ptr = NULL;
         break;
      }
      switch(ntype) {
      case '\n': break;
      case 'I':
         n=GetIntField('I',del,vbuf,src);
         if (n < 0 || n >= lat->nn){
            Dispose(heap, lat);
            HRError(8251,"ReadLattice: Lattice does not contain node %d",n);
            return(NULL);
         }
         ln=lat->lnodes+n;
         if (ln->hook!=NULL){
            Dispose(heap, lat);
            HRError(8251,"ReadLattice: Duplicate info info for node %d",n);
            return(NULL);
         }
         time=0.0;wordId=voc->nullWord;tag=NULL;v=-1;
         while((ptr=GetNextFieldName(nbuf,&del,src)) != NULL) {
            if (nbuf[0]=='\n') break;
            else {
               if (strlen(ptr)>=1) 
                  ntype=*ptr;
               else 
                  ntype=0;
               switch(ntype) {
               case 't':
                  time=GetFltField('t',del,vbuf,src);
                  time *= tscale;
                  lat->format |= HLAT_TIMES;
                  break;
               case 'W':
                  GetFieldValue(vbuf,src,0);
                  wordId=GetWord(voc,GetLabId(vbuf,add2Dict),add2Dict);
                  if (wordId==NULL){
                     Dispose(heap, lat);
                     HRError(8251,"ReadLattice: Word %s not in dict",vbuf);
                     return(NULL);
                  }
                  break;
               case 's':
                  GetFieldValue(vbuf,src,0);
                  tag=CopyString(heap,vbuf);
                  lat->format |= HLAT_TAGS;
                  break;
               case 'L':
                  GetFieldValue(vbuf,src,0);
                  wordId=voc->subLatWord;
                  if((subLatId=AdjSubList(lat,GetLabId(vbuf,TRUE),NULL,+1))==NULL) {
                     HRError(8251,"ReadLattice: AdjSubLat failed");
                     return(NULL);
                  }

                  break;
               case 'v':
                  lat->format |= HLAT_PRON;
                  v=GetIntField('v',del,vbuf,src);
                  break;
               default:
                  GetFieldValue(0,src,0);
                  break;
               }
            }
         }
         if (wordId != voc->nullWord)
            lat->format &= ~HLAT_ALABS;
         ln->time=time;
         ln->word=wordId;
         ln->tag=tag;
         ln->v=v;
         if (wordId == voc->subLatWord)
            ln->sublat = subLatId;
         else
            ln->sublat = NULL;
         ln->hook=ln;
         nn--;
         break;
      case 'J':
         n=GetIntField('I',del,vbuf,src);
         if (n<0 || n>=lat->na){
            Dispose(heap, lat);
            HRError(8251,"ReadLattice: Lattice does not contain arc %d",n);
            return(NULL);
         }
         la=NumbLArc(lat,n);
         if (la->start!=NULL){
            Dispose(heap, lat);
            HRError(8251,"ReadLattice: Duplicate info for arc %d",n);
            return(NULL);
         }
         s=e=v=-1; wordId=NULL; aclike=lmlike=0.0;
         prlike=0.0;
         while ((ptr=GetNextFieldName(nbuf,&del,src))) {
            if (nbuf[0]=='\n') break;
            else {
               if (strlen(ptr)>=1) ntype=*ptr;
               else ntype=0;
               switch(ntype)
                  {
                  case 'S':
                     s=GetIntField('S',del,vbuf,src);
                     if (s<0 || s>=lat->nn){
                        Dispose(heap, lat);
                        HRError(8251,"ReadLattice: Lattice does not contain start node %d",s);
                        return(NULL);
                     }
                     break;
                  case 'E':
                     e=GetIntField('E',del,vbuf,src);
                     if (e<0 || e>=lat->nn){
                        Dispose(heap, lat);
                        HRError(8251,"ReadLattice: Lattice does not contain end node %d",e);
                        return(NULL);
                     }
                     break;
                  case 'W':
                     GetFieldValue(vbuf,src,0);
                     wordId=GetWord(voc,GetLabId(vbuf,add2Dict),add2Dict);
                     if (wordId==NULL || wordId==voc->subLatWord){
                        Dispose(heap, lat);
                        HRError(8251,"ReadLattice: Word %s not in dict",
                                vbuf);
                        return(NULL);
                     }
                     break;
                  case 'v':
                     lat->format |= HLAT_PRON;
                     v=GetIntField('v',del,vbuf,src);
                     break;
                  case 'a':
                     lat->format |= HLAT_ACLIKE;
                     aclike=GetFltField('a',del,vbuf,src);
                     aclike = ConvLogLikeFromBase(logbase, aclike);
                     break;
                  case 'l':
                     lat->format |= HLAT_LMLIKE;
                     lmlike=GetFltField('l',del,vbuf,src);
                     lmlike = ConvLogLikeFromBase(logbase, lmlike);
                     break;
                  case 'r':
                     lat->format |= HLAT_PRLIKE;
                     prlike=GetFltField('r',del,vbuf,src);
                     prlike = ConvLogLikeFromBase(logbase, prlike);
                     break;
                  case 'd':
                     lat->format |= HLAT_ALIGN;
                     GetFieldValue(dbuf,src,DBUFLEN);
                     if (!shortArc)
                        la->nAlign=ReadAlign(lat,la,dbuf);
                     break;
                  default:
                     GetFieldValue(0,src,0);
                     break;
                  }
            }
         }
         if (s<0 || e<0 ||(wordId==NULL && (lat->format&HLAT_ALABS))){
            Dispose(heap, lat);
            HRError(8250,"ReadLattice: Need to know S,E [and W] for arc %d",n);
            return(NULL);
         }
         la->start=lat->lnodes+s;
         la->end=lat->lnodes+e;
         la->lmlike=lmlike;
           
         if ((lat->format&HLAT_ALABS) && la->end->word == voc->nullWord){
            la->end->word=wordId;
	    la->end->v = v;
	 }
         if (wordId != NULL && la->end->word != wordId){
            Dispose(heap, lat);
            HRError(8251,"ReadLattice: Lattice arc (%d) W field (%s) different from node (%s)",  n,wordId->wordName->name,la->end->word->wordName->name);
            return(NULL);
         }

         la->farc=la->start->foll;
         la->parc=la->end->pred;
         la->start->foll=la;
         la->end->pred=la;
         if (!shortArc) {
            la->aclike=aclike;
            la->prlike=prlike;
         }
         na--;
         break;
      default:
         GetFieldValue(0,src,0);
         while ((ptr=GetNextFieldName(nbuf,&del,src))) {
            if (nbuf[0]=='\n') break;
            else GetFieldValue(0,src,0);
         }
         break;
      }
   }
   while(ptr != NULL);
   if (na!=0 || (nn!=0 && nn!=lat->nn)){
      Dispose(heap, lat);
      HRError(8250,"ReadLattice: %d Arcs unseen and %d Nodes unseen",na,nn);
      return(NULL);
   }

   if(CheckStEndNodes(lat)<SUCCESS){
      Dispose(heap, lat);
      HRError(8250,"ReadLattice: Start/End nodes incorrect",na,nn);
      return(NULL);
   }

   for(i=0,ln=lat->lnodes;i<lat->nn;i++,ln++)
      ln->hook=NULL;
   if (shortArc) lat->format&=~(HLAT_ACLIKE|HLAT_PRLIKE|HLAT_ALIGN);
   return(lat);
}


/* EXPORT->ReadLattice: Read lattice from file - calls ReadOneLattice */
/*                      for each level of a multi-level lattice file  */
Lattice *ReadLattice(FILE *file, MemHeap *heap, Vocab *voc, 
                     Boolean shortArc, Boolean add2Dict)
{
   Lattice *lat,*list,*fLat;
   Source source;
 
   AttachSource(file,&source);

   if((lat=ReadOneLattice(&source,heap,voc,shortArc,add2Dict))==NULL)
      return NULL;

   if (lat->subLatId!=NULL) {
      /* Need to preserve first lattice to return */
      fLat=lat; lat = (Lattice *) New(heap,sizeof(Lattice)); *lat=*fLat;
      do {
         /* Add SUBLAT to hash table for later lookup */
         GetSubLat(lat->subLatId,lat);
         if((lat=ReadOneLattice(&source,heap,voc,shortArc,add2Dict))==NULL){
            Dispose(heap, fLat); /*fLat points to 1st thing on heap*/
            return NULL;
         }               

      }
      while(lat->subLatId!=NULL);