hlabel.c

来自「隐马尔科夫模型工具箱」· C语言 代码 · 共 1,565 行 · 第 1/3 页

}

/* FindMLFStr: find the next quoted string in s */
static Boolean FindMLFStr(char *s, char **st, char **en)
{
   char *p,*q;
   
   if (s==NULL || *s == '\0') return FALSE;
   p = strchr(s,'"');
   if (p==NULL || *(p+1)=='\0') return FALSE;
   q = strchr(p+1,'"');
   if (q==NULL) return FALSE;
   *st = p; *en = q;
   return TRUE;
}

/* FindMLFType: find a -> or => symbol in s if any */
static MLFDefType FindMLFType(char *s, char **en)
{
   char *p;
   
   p=strchr(s+1,'>');
   if (p!=NULL) {
      *en = p;
      if (*(p-1) == '-') return MLF_SIMPLE;
      if (*(p-1) == '=') return MLF_FULL;
   }
   return MLF_IMMEDIATE;
}

/* NoMLFHeader: return true if s doesnt contain #!MLF!# */
static Boolean NoMLFHeader(char *s)
{
   int len;
   char *e;
   
   len = strlen(s);
   while (isspace(*s) && len>7) {
      --len; ++s;
   }
   e = s+len-1;
   while (isspace(*e) && len>7) {
      --len; --e;
   }
   if (len != 7) return TRUE;
   *(e+1) = '\0';
   return (strcmp(s,"#!MLF!#") != 0);
}

static Boolean incSpaces;

/* IsDotLine: return true if line contains only a single dot */
static Boolean IsDotLine(char *s)
{
   int len;
   char *e;
   Boolean cut;

   len = strlen(s);cut=FALSE;
   if (s[len-1]=='\n') {
      len--; s[len]=0;
      if ((len>0) && (s[len-1]=='\r')) {
         len--; s[len]=0;
      }
   }
   if (compatMode) {
      while (isspace(*s) && len>0) {
         cut=TRUE;
         --len; ++s;
      }
      e = s+len-1;
      if (*e=='\n' && len>0) --len,--e;
      while (isspace(*e) && len>0) {
         cut=TRUE;
         --len; --e;
      }
   }
   if ((*s == '.') && (len == 1)) {
      if (cut) incSpaces=TRUE;
      return(TRUE);
   }
   if (compatMode && cut && len==strlen_LEVELSEP && 
       strncmp(s,LEVELSEP,strlen_LEVELSEP)==0)
      incSpaces=TRUE;
   return(FALSE);
}

/* ClassifyMLFPattern: classify given pattern string */
MLFPatType ClassifyMLFPattern(char *s)
{
   char *t;
   
   if (strchr(s,'?') != NULL) return PAT_GENERAL;
   if (strchr(s,'*') == NULL) return PAT_FIXED;
   if (strlen(s)<=2) return PAT_GENERAL;
   if (s[0]!='*' || s[1]!=PATHCHAR) return PAT_GENERAL;
   t = s+2;
   if (strchr(t,'*') == NULL ) return PAT_ANYPATH;
   return PAT_GENERAL;
}

/* MLFHash: hash the given string */
static unsigned MLFHash(char *s)
{
   unsigned hashval;

   for (hashval=0; *s != '\0'; s++)
      hashval = *s + 31*hashval;
   return hashval;
}

/* EXPORT->LoadMasterFile: Load the Master Label File stored in fname 
                           and append the entries to the MLF table */
void LoadMasterFile(char *fname)
{
   char buf[1024];
   char *men;        /* end of mode indicator */
   char *pst,*pen;   /* start/end of pattern (inc quotes) */
   char *dst,*den;   /* start/end of subdirectory (inc quotes) */
   Boolean inEntry = FALSE;   /* ignore ".." within an entry */
   MLFEntry *e;
   FILE *f;
   
   if (numMLFs == MAXMLFS)
      HError(6520,"LoadMasterFile: MLF file limit reached [%d]",MAXMLFS);
   if ((f = fopen(fname,"rb")) == NULL)
      HError(6510,"LoadMasterFile: cannot open MLF %s",fname);
   if (fgets(buf,1024,f) == NULL)
      HError(6513,"LoadMasterFile: MLF file is empty");
   if (NoMLFHeader(buf))
      HError(6551,"LoadMasterFile: MLF file header is missing"); 
   incSpaces=FALSE;
   while (fgets(buf,1024,f) != NULL){
      if (!inEntry && FindMLFStr(buf,&pst,&pen)) {
         e = (MLFEntry *)New(&mlfHeap,sizeof(MLFEntry));
         e->type = FindMLFType(pen+1,&men);
         if (e->type == MLF_IMMEDIATE) {
            e->def.immed.fidx = numMLFs;
            e->def.immed.offset = ftell(f);
            if (e->def.immed.offset < 0)
               HError(6521,"LoadMasterFile: cant ftell on MLF file");
            inEntry = TRUE;
         } else {
            if (!FindMLFStr(men+1,&dst,&den))
               HError(6551,"LoadMasterFile: Missing subdir in MLF\n(%s)",buf);
            *den = '\0';
            e->def.subdir = NewString(&mlfHeap,den-dst-1);
            strcpy(e->def.subdir,dst+1);
         }
         *pen = '\0';         /* overwrite trailing pattern quote */
         ++pst;               /* skipover leading pattern quote */
         e->patType = ClassifyMLFPattern(pst);
         if (e->patType == PAT_ANYPATH) 
            pst += 2;         /* skipover leading "* /" */
         e->pattern = NewString(&mlfHeap,pen-pst);
         strcpy(e->pattern,pst);
         e->patHash = (e->patType==PAT_GENERAL)?0:MLFHash(e->pattern);
         StoreMLFEntry(e);
      } else
         if (inEntry && IsDotLine(buf)) inEntry = FALSE;
   }
   if (compatMode && incSpaces)
      HError(-6551,"LoadMasterFile: . or %s on line with spaces in %s",
             LEVELSEP,fname);
   mlfile[numMLFs++] = f;
}

/* EXPORT->NumMLFFiles: return number of loaded MLF files */
int NumMLFFiles(void)
{
   return numMLFs;
}

/* EXPORT->NumMLFEntries: return number of entries in the MLFTab */
int NumMLFEntries(void)
{
   return mlfUsed;
}

/* EXPORT->GetMLFFile: return fidx'th MLF file pointer */
FILE *GetMLFFile(int fidx)
{
   if (fidx<0 || fidx>=numMLFs)
      HError(6520,"GetMLFFile: fidx out of range[%d]",fidx);
   return mlfile[fidx];
}

/*EXPORT->IsMLFFile: return true if fn is an MLF */
Boolean IsMLFFile(char *fn)
{
   FILE *f;
   char buf[1024];
   
   if ((f = fopen(fn,"rb")) == NULL) return FALSE;
   if (fgets(buf,1024,f) == NULL) {
      fclose(f); return FALSE;
   }
   if (NoMLFHeader(buf)) {
      fclose(f); return FALSE;
   }
   fclose(f); return TRUE;
}

/* EXPORT->GetMLFEntry: Return the first entry in the MLF table */
MLFEntry *GetMLFTable(void)
{
   return mlfHead;
}

/* SplitPath: last name in path is removed and prefixed to name, then
              this new name is suffixed to subdir and stored in tryspec */            
static void SplitPath(char *path, char *name, char *subdir, char *tryspec)
{
   char buf1[1024],buf2[1024],*p;
   char pch[2] = " ";
   
   pch[0] = PATHCHAR;
   PathOf(path,buf1); NameOf(path,buf2);
   if (strlen(name)>0 ) strcat(buf2,pch);    /* new name */
   strcat(buf2,name); strcpy(name,buf2);
   p = buf1+strlen(buf1)-1;                  /* new path */
   if (*p == PATHCHAR) *p = '\0';
   strcpy(path,buf1);   
   strcpy(buf1,subdir);                      /* tryspec */
   p = buf1+strlen(buf1)-1;
   if (*p != PATHCHAR) strcat(buf1,pch);
   strcat(buf1,name);
   strcpy(tryspec,buf1);
}

/* OpenLabFile: opens a file corresponding to given fname, the file
                returned may be a real file or simply the MLF seek'ed
                to the start of an immediate file definition, isMLF
                tells you which it is.  Returns NULL if nothing found  */
static FILE * OpenLabFile(char *fname, Boolean *isMLF)
{
   FILE *f;
   MLFEntry *e;
   char path[1024],name[256],tryspec[1024];
   Boolean isMatch;
   unsigned fixedHash;     /* hash value for PAT_FIXED */
   unsigned anypathHash;   /* hash value for PAT_ANYPATH */ 
   char *fnStart;          /* start of actual file name */
   static MLFEntry *q=NULL;/* entry after last one accessed - checked first */
   
   *isMLF = FALSE; 
   fixedHash = anypathHash = MLFHash(fname);
   fnStart = strrchr(fname,PATHCHAR);
   if (fnStart != NULL) {
      ++fnStart;
      anypathHash = MLFHash(fnStart);
   } else 
      fnStart = fname;
   if (trace&T_MLF)
      printf("HLabel: Searching for label file %s\n",fname);
   if (trace&T_MHASH) 
      printf("HLabel:  anypath hash = %d;  fixed hash = %d\n",anypathHash,fixedHash);
   for (e=(q==NULL?mlfHead:q); e != NULL; e = (e==NULL?mlfHead:e->next)) {
      switch (e->patType){
      case PAT_GENERAL:
         if (trace&T_MAT) 
            printf("HLabel:  general match against %s\n",e->pattern);
         isMatch = DoMatch(fname,e->pattern);
         break;
      case PAT_ANYPATH:
         if (trace&T_MAT) 
            printf("HLabel:  anypath match against %s[%d]\n",e->pattern,e->patHash);
         if (e->patHash == anypathHash)
            isMatch = strcmp(e->pattern,fnStart) == 0;
         else
            isMatch = FALSE;
         break;
      case PAT_FIXED:
         if (trace&T_MAT) 
            printf("HLabel:  fixed match against %s[%d]\n",e->pattern,e->patHash);
         if (e->patHash == fixedHash)
            isMatch = strcmp(e->pattern,fname) == 0;
         else
            isMatch = FALSE;
         break;
      }
      if ( isMatch ) {
         if (e->type == MLF_IMMEDIATE) {
            f = mlfile[e->def.immed.fidx];
            if (fseek(f,e->def.immed.offset,SEEK_SET) != 0)
               HError(6521,"OpenLabFile: cant seek to label def in MLF");
            *isMLF=TRUE;
            if (trace&T_MLF)
               printf("HLabel: Loading Immediate Def [Pattern %s]\n",
                      e->pattern);
            q=e->next;
            return f;
         } else {
            name[0] = '\0'; strcpy(path,fname);
            SplitPath(path,name,e->def.subdir,tryspec);
            if (trace&T_SUBD)
               printf("HLabel: trying %s\n",tryspec);
            f = fopen(tryspec,"rb");
            while (f==NULL && e->type == MLF_FULL && strlen(path)>0) {
               SplitPath(path,name,e->def.subdir,tryspec);
               if (trace&T_SUBD)
                  printf("HLabel: trying %s\n",tryspec);
               f = fopen(tryspec,"rb");
            }
            if (f != NULL) {
               if (trace&T_MLF)
                  printf("HLabel: Loading Label File %s [Pattern %s]\n",
                         tryspec,e->pattern);
               return f;
            }
         }
      }
      if (q!=NULL) e=NULL;
      q = NULL;
   }
   /* No MLF Match so try direct open */  
   if (trace&T_SUBD)
      printf("HLabel: trying actual file %s\n",fname);
   f = fopen(fname,"rb");
   if (f !=NULL && trace&T_MLF)
      printf("HLabel: Loading Actual Label File %s\n", fname);
   return f;
}

/* ------------------ Label File Opening/Closing -------------------- */

/* EXPORT->LOpen: Load transcription in fname and return it */
Transcription *LOpen(MemHeap *x, char * fname, FileFormat fmt)
{
   FILE *f;
   Source source;
   char buf[MAXSTRLEN];
   Transcription *t;
   Boolean isMLF;

   if (fmt == UNDEFF){
      if (GetConfStr(cParm,numParm,"SOURCELABEL",buf))
         fmt = Str2Format(buf);
      else
         fmt = HTK;
   }
   if ((f=OpenLabFile(fname, &isMLF)) == NULL)
      HError(6510,"LOpen: Unable to open label file %s",fname);
   AttachSource(f,&source);
   strcpy(source.name,fname);
   t = CreateTranscription(x);
   switch (fmt) {
   case TIMIT:    LoadTIMITLabels(x,t,&source); break;
   case HTK:      LoadHTKLabels(x,t,&source); break;
   case SCRIBE:   LoadSCRIBELabels(x,t,&source); break;
   case ESPS:     LoadESPSLabels(x,t,&source); break;
   default:
      HError(6572,"LOpen: Illegal label file format [%d]",fmt);
   }
   if (!isMLF) fclose(f);
   if (transLev > 0) FilterLevel(t,transLev-1);
   return t;
}
   
/* EXPORT->SaveToMasterfile: make all subsequent LSaves go to fname */
ReturnStatus SaveToMasterfile(char *fname)
{
   int i;
   LabId nid;
   OutMLFEntry *omlf;
   char buf[MAXSTRLEN];

   if (fname==NULL || *fname=='\0') {
      outMLF=NULL; 
      return (FAIL);
   }
   sprintf(buf,"#!MLF-%s!#",fname);
   if ((nid=GetLabId(buf,FALSE))!=NULL) {
      for (omlf=outMLFSet, i=0; i<numOutMLF; i++, omlf++)
         if (omlf->name==nid) break;
      if (i<numOutMLF) {
         if ((outMLF = omlf->file)==NULL){
            HRError(6511,"SaveToMasterfile: MLF file %s already closed",fname);
            return(FAIL);
         }
         return(SUCCESS);
      }
   }
   if (numOutMLF==MAXMLFS-1){
      HRError(6511,"SaveToMasterfile: Unable to create MLF file %s",fname);
      return(FAIL);
   }
   if ((outMLF=fopen(fname,"w")) == NULL){
      HRError(6511,"SaveToMasterfile: Unable to create MLF file %s",fname);
      return(FAIL);
   }
   fprintf(outMLF,"#!MLF!#\n");
   nid = GetLabId(buf,TRUE);
   outMLFSet[numOutMLF].file = outMLF;
   outMLFSet[numOutMLF].name = nid;
   numOutMLF++;
   return(SUCCESS);
}

/* EXPORT->CloseMLFSaveFile: Close the MLF output file */
void CloseMLFSaveFile(void)
{
   int i;
   OutMLFEntry *omlf;

   if (outMLF != NULL) {
      fclose(outMLF);
      for (omlf=outMLFSet,i=0; i<numOutMLF; i++,omlf++)
         if (omlf->file==outMLF) {
            omlf->file = NULL;
            break;
         }
      outMLF = NULL;
   }
}

/* SaveESPSLabels: Save transcription in f using ESPSwaves format */
static void SaveESPSLabels( FILE *f, Transcription *t)
{
   LabList *ll;
   LLink p;
   
   if ( t->numLists > 1 )
      HError(6572,"SaveESPSLabels: can't save multiple level transcription.");
   fprintf(f,"#\n");    /* Write waves label header */
   ll = t->head;
   for (p=ll->head->succ; p->succ != NULL; p=p->succ)
      fprintf(f,"%f 121 %s\n", (p->end+0.5)*1E-7, p->labid->name);
}

/* SaveHTKLabels: Save transcription in f using HTK format */
static void SaveHTKLabels( FILE *f, Transcription *t) 
{
   int i,j;
   LabList *ll;
   LLink p,hd;
   LabId id;
   Boolean hasScores[100];

   ll = t->head;
   for (i=1; i<=t->numLists; i++,ll=ll->next){
      hd = ll->head;
      /* See which columns have scores */
      for (j=0; j<=ll->maxAuxLab; j++)
         hasScores[j] = FALSE;
      for (p = hd->succ; p->succ != NULL; p = p->succ){
         if (p->score != 0.0)
            hasScores[0] = TRUE;
         for (j=1; j<=ll->maxAuxLab; j++)
            if (p->auxScore[j] != 0.0)
               hasScores[j] = TRUE;
      }
      for (p = hd->succ; p->succ != NULL; p = p->succ) {
         if (p->start>=0.0) {
            fprintf(f,"%.0f ",p->start);
            if (p->end>=0.0) 
               fprintf(f,"%.0f ",p->end);
         }
         WriteString(f,p->labid->name,labelQuote);
         if (hasScores[0])
            fprintf(f," %f",p->score);
         for (j=1; j<=ll->maxAuxLab; j++) {
            id = p->auxLab[j];
            if (id !=NULL){
               fputc(' ',f);
               WriteString(f,id->name,labelQuote);
               if (hasScores[j])
                  fprintf(f," %f",p->auxScore[j]);
            }
         }
         fprintf(f,"\n");
      }
      if (i<t->numLists)
         fprintf(f,"%s\n",LEVELSEP);
   }
}

/* EXPORT->LSave: Save transcription in fname */
ReturnStatus LSave(char *fname, Transcription *t, FileFormat fmt)
{
   FILE *f;
   char buf[MAXSTRLEN];

   if (fmt == UNDEFF){
      if (GetConfStr(cParm,numParm,"TARGETLABEL",buf))
         fmt = Str2Format(buf);
      else
         fmt = HTK;
   }
   if (outMLF != NULL) {
      if (fmt != HTK){
         HRError(6572,"LSave: cant save to MLF in %s format",Format2Str(fmt));
         return(FAIL);
      }
      f = outMLF;                      /* save to MLF file */
      fprintf(f,"\"%s\"\n",fname);
   } else                              /* else open new one */
      if ((f=fopen(fname,"wb")) == NULL){
         HRError(6511,"LSave: Unable to create label file %s",fname);
         return(FAIL);
      }
   if (trace&T_SAV)
      printf("HLabel: Saving transcription to %s in format %s\n",
             fname,Format2Str(fmt));
   switch (fmt) {
   case HTK:    SaveHTKLabels( f, t);   break;
   case ESPS:   SaveESPSLabels(f, t);   break;
   default: HRError(6572,"LSave: Illegal label file format."); 
      fclose(f);
      return(FAIL);
      break;
   }
   if (outMLF != NULL && fmt==HTK){
      fprintf(f,".\n");  fflush(f);
   }else
      fclose(f);
   return(SUCCESS);
}

/* ------------------------ End of HLabel.c ------------------------- */