hmodel.c

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

      } else{
         HMError(src,"Variance or Xform expected in GetMixPDF");
         return(NULL);
      }
      if (tok->sym==GCONST) {
         ReadFloat(src,&mp->gConst,1,tok->binForm);
         
         if(GetToken(src,tok)<SUCCESS){
            HMError(src,"GetToken failed");
            return(NULL);
         }
      }
   }
   return mp;  
}

/* CreateCME: create an array of M Continuous MixtureElems */
static MixtureElem *CreateCME(HMMSet *hset, int M)
{
   int m;
   MixtureElem *me,*p;
   
   me = (MixtureElem *)New(hset->hmem,M*sizeof(MixtureElem));
   p = me-1;
   for (m=1;m<=M;m++,me++){
      me->weight = 0.0; me->mpdf = NULL;
   }
   return p;
}

/* CreateTME: create an array of M Tied Mix Weights (ie floats) */
static Vector CreateTME(HMMSet *hset, int M)
{
   int m;
   Vector v;
   
   v = CreateVector(hset->hmem,M);
   for (m=1;m<=M;m++)
      v[m] = 0;
   return v;
}

/* CreateDME: create an array of M Discrete Mix Weights (ie shorts) */
static ShortVec CreateDME(HMMSet *hset, int M)
{
   int m;
   ShortVec v;
   
   v = CreateShortVec(hset->hmem,M);
   for (m=1;m<=M;m++)
      v[m] = 0;
   return v;
}

/* GetMixture: parse src and store a MixtureElem in spdf array */
static ReturnStatus GetMixture(HMMSet *hset,Source *src,Token *tok,int M,MixtureElem *spdf)
{
   float w = 1.0;
   short m = 1;

   if (trace&T_PAR) printf("HModel: GetMixture\n");
   if (tok->sym == MIXTURE) {
      if (!ReadShort(src,&m,1,tok->binForm)){
         HMError(src,"Mixture Index expected");
         return(FAIL);
      }
      if (m<1 || m>M){
         HMError(src,"Mixture index out of range");
         return(FAIL);
      }
      if (!ReadFloat(src,&w,1,tok->binForm)){
         HMError(src,"Mixture Weight expected");
         return(FAIL);
      }
      if(GetToken(src,tok)<SUCCESS){
         HMError(src,"GetToken failed");
         return(FAIL);
      }
   }
   spdf[m].weight = w;
   if((spdf[m].mpdf = GetMixPDF(hset,src,tok))==NULL){
      HMError(src,"Regression Class Number expected");
      return(FAIL);
   }
   return(SUCCESS);
}
   
/* CreateSE: create an array of S StreamElems */
static StreamElem *CreateSE(HMMSet *hset, int S)
{
   int s;
   StreamElem *se,*p;
   
   se = (StreamElem *)New(hset->hmem,S*sizeof(StreamElem));
   p = se-1;
   for (s=1;s<=S;s++,se++){
      se->hook = NULL;
      se->spdf.cpdf = NULL;
   }
   return p;
}

/* EmptyMixPDF: return an empty Diag Covariance MixPDF */
static MixPDF *EmptyMixPDF(HMMSet *hset, int vSize, int s)
{
   int i;
   static Boolean isInitialised = FALSE;
   static MixPDF *t[SMAX];
   static int size[SMAX];

   if (!isInitialised){
      for (i=0; i<SMAX; i++) t[i]=NULL;
      isInitialised = TRUE;
   }
   if (t[s] != NULL) {
      if (size[s] != vSize){
         HRError(7090,"EmptyMixPDF: Size mismatch %d vs %d in EmptyDiagMixPDF",
                 vSize,size[s]);
         return(NULL);
      }
   }
   size[s] = vSize;
   t[s] = (MixPDF *)New(hset->hmem,sizeof(MixPDF));
   t[s]->ckind = DIAGC;
   t[s]->nUse = 0; t[s]->hook = NULL; t[s]->gConst = LZERO;
   t[s]->mIdx = 0;
   t[s]->mean = CreateSVector(hset->hmem,vSize);
   ZeroVector(t[s]->mean);
   t[s]->cov.var = CreateSVector(hset->hmem,vSize);
   for (i=1; i<=vSize; i++) t[s]->cov.var[i] = 1.0;
   return t[s];
}

/* GetStream: parse src and store a StreamElem in pdf array */
static ReturnStatus GetStream(HMMSet *hset, Source *src, Token *tok,
                              StreamElem *pdf, short *nMix)
{
   int m,S,M;
   short s;
   MixtureElem *cpdf;
  
   S=hset->swidth[0];
   if (trace&T_PAR) {
      printf("HModel: GetStream - nMix =");
      for (s=1; s<=S; s++) printf(" %d",nMix[s]);
      printf("\n");
   }
   s = 1;
   if (tok->sym == STREAM) {
      if (!ReadShort(src,&s,1,tok->binForm)){
         HMError(src,"Stream Index expected");
         return(FAIL);
      }
      if (s<1 || s>S){
         HMError(src,"Stream Index out of range");
         return(FAIL);
      }
      if(GetToken(src,tok)<SUCCESS){
         HMError(src,"GetToken failed");
         return(FAIL);
      }
   }
   M = nMix[s];
   pdf[s].nMix = M;
   if (tok->sym == TMIX ) {
      if (hset->hsKind == PLAINHS)
         hset->hsKind = TIEDHS;
      else 
         if (hset->hsKind != TIEDHS){
            HRError(7032,"GetStream: change to TIEDHS from other than PLAINHS");
            return(FAIL);
         }
      pdf[s].spdf.tpdf = CreateTME(hset,M);
      if((GetTiedMixtures(hset,src,tok,M,s,pdf[s].spdf.tpdf))<SUCCESS){
         HMError(src,"GetTiedMixtures failed");
         return(FAIL);
      }
   } 
   else 
      if (tok->sym == DPROB) {
         if (hset->hsKind == PLAINHS)
            hset->hsKind = DISCRETEHS;
         else if (hset->hsKind != DISCRETEHS){
            HRError(7032,"GetStream: change to DISCRETEHS from other than PLAINHS");
            return(FAIL);
         }
         pdf[s].spdf.dpdf = CreateDME(hset,M);
         if((GetDiscreteWeights(src,tok,M,pdf[s].spdf.dpdf))<SUCCESS){
            HMError(src,"GetDiscreteWeights failed");
            return(FAIL);
         }
      } else {  /* PLAIN/SHARED Mixtures */
         cpdf = pdf[s].spdf.cpdf = CreateCME(hset,M);
         if((GetMixture(hset,src,tok,M,cpdf))<SUCCESS){
            HMError(src,"GetMixtures failed");
            return(FAIL);
         }
         while (tok->sym==MIXTURE)
            if((GetMixture(hset,src,tok,M,cpdf))<SUCCESS){
               HMError(src,"GetMixtures failed");
               return(FAIL);
            }
         for (m=1; m<=M; m++)
            if (cpdf[m].mpdf == NULL){
               if((cpdf[m].mpdf = EmptyMixPDF(hset,hset->swidth[s],s))==NULL){
                  HMError(src,"EmptyMixPDF failed");
                  return(FAIL);
               }
               cpdf[m].weight = 0.0;
            }
      }
   return(SUCCESS);
}
  
/* GetStateInfo: parse src and return StateInfo structure  */
static StateInfo *GetStateInfo(HMMSet *hset, Source *src, Token *tok)
{
   StateInfo *si;
   int i,S;
   short nMix[SMAX];

   if (trace&T_PAR) printf("HModel: GetStateInfo\n");
   S = hset->swidth[0];
   if (tok->sym==MACRO && tok->macroType=='s') {
      if((si = (StateInfo *)GetStructure(hset,src,'s'))==NULL){
         HMError(src,"GetStructure failed");
         return(NULL);
      }
      ++si->nUse;
      if(GetToken(src,tok)<SUCCESS){
         HMError(src,"GetToken failed");
         return(NULL);
      }
   } else {
      if (tok->sym == NUMMIXES){
         if (!ReadShort(src,nMix+1,S,tok->binForm)){
            HMError(src,"Num Mix in Each Stream expected");
            return(NULL);
         }
         if(GetToken(src,tok)<SUCCESS){
            HMError(src,"GetToken failed");
            return(NULL);
         }
      } else {
         for (i=1;i<=S;i++)
            nMix[i] = 1;
      }
      si = (StateInfo *)New(hset->hmem,sizeof(StateInfo));
      si->nUse = 0; si->hook = NULL; si->weights = NULL;
      si->pdf = CreateSE(hset,S);
      if (tok->sym==SWEIGHTS || (tok->sym==MACRO && tok->macroType=='w')){
         if((si->weights = GetSWeights(hset,src,tok))==NULL){
            HMError(src,"GetSWeights failed");
            return(NULL);
         }
         if (VectorSize(si->weights) != S){
            HMError(src,"Incorrect number of stream weights");
            return(NULL);
         }
      }
      if((GetStream(hset,src,tok,si->pdf,nMix))<SUCCESS){
         HMError(src,"GetStream failed");
         return(NULL);
      }
      while(tok->sym==STREAM)
         if((GetStream(hset,src,tok,si->pdf,nMix))<SUCCESS){
            HMError(src,"GetStream failed");
            return(NULL);
         }
      if (tok->sym==DURATION || (tok->sym==MACRO && tok->macroType=='d')){
         if((si->dur = GetDuration(hset,src,tok))==NULL){
            HMError(src,"GetDuration failed");
            return(NULL);
         }
      }
      else
         si->dur = NULL;
   }
   if (S>1 && si->weights == NULL) {
      si->weights = CreateSVector(hset->hmem,S);
      for (i=1;i<=S;i++)
         si->weights[i] = 1.0;
   }
   return si;  
}

/* GetTransMat: parse src and return Transition Matrix structure */
static SMatrix GetTransMat(HMMSet *hset, Source *src, Token *tok)
{
   SMatrix m;
   int i,j;
   short size;
   Vector v;
   float rSum;
   
   if (trace&T_PAR) printf("HModel: GetTransMat\n");
   if (tok->sym == TRANSP) {
      if (!ReadShort(src,&size,1,tok->binForm)){
         HMError(src,"Size of Transition matrix expected");
         return(NULL);
      }
      if (size < 1){
         HRError(7031,"GetTransMat: Bad size of transition matrix: %d\n", size);
         return(NULL);
      }
      m = CreateSMatrix(hset->hmem,size,size);
      if (!ReadMatrix(src,m,tok->binForm)){
         HMError(src,"Transition Matrix expected");
         return(NULL);
      }
      if (!hset->allowTMods && (m[1][size] > 0.0)) { /* kill teeModel */
         rSum = 0.0; v = m[1]; v[size] = 0.0;
         for (j=1;j<size;j++) rSum += v[j];
         for (j=1;j<size;j++) v[j] /= rSum;
      }     
      for (i=1;i<size;i++){                       /* convert to logs */
         v=m[i]; rSum = 0.0;
         for (j=1;j<=size;j++){
            rSum += v[j];
            v[j] = (v[j]<=MINLARG) ? LZERO : log(v[j]);
         }
         if (rSum<0.99 || rSum>1.01){
            HRError(7031,"GetTransMat: Bad Trans Mat Sum in Row %d\n",i);
            return(NULL);
         }
      }
      v = m[size];
      for (j=1;j<=size;j++)
         v[j] =  LZERO;
   } else {
      if((m = (SMatrix)GetStructure(hset,src,'t'))==NULL){
         HMError(src,"GetStructure failed");
         return(NULL);
      }
      IncUse(m);
   }
   if(GetToken(src,tok)<SUCCESS){
      HMError(src,"GetToken failed");
      return(NULL);
   }
   return m;
}

/* GetHMMDef: get a hmm def from given source */
static ReturnStatus GetHMMDef(HMMSet *hset, Source *src, Token *tok,
                              HLink hmm, int nState)
{
   short state;
   int N=0;
   StateElem *se;
   char buf[MAXSTRLEN];
   
   if (trace&T_PAR) printf("HModel: GetHMMDef\n");
   if (tok->sym != BEGINHMM){
      HMError(src,"<BeginHMM> symbol expected");
      return(FAIL);
   }
   if(GetToken(src,tok)<SUCCESS){
      HMError(src,"GetHMMDef: GetToken failed");
      return(FAIL);
   }
   if (tok->sym == USEMAC){      /* V1 style USE clause */
      if (!ReadString(src,buf)){
         HRError(7013,"GetHMMDef: cannot read USE macro name");
         return(FAIL);
      }
      if(GetToken(src,tok)<SUCCESS){
         HMError(src,"GetHMMDEf: GetToken failed");
         return(FAIL);
      }
   }
   while (tok->sym != STATE) {
      if(GetOption(hset,src,tok, &N)<SUCCESS){
         HMError(src,"GetHMMDef: GetOption failed");
         return(FAIL);
      }
      if (N>nState) nState = N;
   }
   FreezeOptions(hset);
   if (nState==0){
      HMError(src,"NumStates not set");
      return(FAIL);
   }
   hmm->numStates = N = nState;
   se = (StateElem *)New(hset->hmem,(N-2)*sizeof(StateElem));
   hmm->svec = se - 2;
   while (tok->sym == STATE) {
      if (!ReadShort(src,&state,1,tok->binForm)){
         HMError(src,"States index expected");
         return(FAIL);
      }
      if (state<2 || state >= N){
         HMError(src,"State index out of range");
         return(FAIL);
      }
      if(GetToken(src,tok)<SUCCESS){
         HMError(src,"GetHMMDef: GetToken failed");
         return(FAIL);
      }
      se = hmm->svec+state;
      if((se->info = GetStateInfo(hset,src,tok))==NULL){
         HMError(src,"GetStateInfo failed");
         return(FAIL);
      }     
   }
   if (tok->sym==TRANSP || (tok->sym==MACRO && tok->macroType=='t')){
      if((hmm->transP = GetTransMat(hset,src,tok))==NULL){
         HMError(src,"GetTransMat failed");
         return(FAIL);
      }     
      if (NumRows(hmm->transP) != N ||
          NumCols(hmm->transP) != N){
         HRError(7030,"GetHMMDef: Trans Mat Dimensions not %d x %d",N,N);
         return(FAIL);
      }
   }
   else{
      HMError(src,"Transition Matrix Missing");
      return(FAIL);
   }
   if (tok->sym==DURATION || (tok->sym==MAC