hparm.c

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

void ResetChannelSession(char *confName)
{
   ChannelInfo *chan;

   if (confName==NULL) chan=defChan;
   else
      for (chan=defChan;chan!=NULL;chan=chan->next) 
         if (strcmp(chan->confName,confName)==0) break;
   if (chan==NULL) chan=defChan;
   chan->sCnt=chan->oCnt=0;
   /* Recalibrate selfCalSilDet every session */
   if (chan->cf.selfCalSilDet!=0) chan->spDetParmsSet=FALSE;
}

/* Keep the next two functions solely for compatibility */
void SetNewConfig(char *confName)
{
   SetChannel(confName);
}


/* ------------------- Buffer Status Operations --------------- */

static void FillBufFromChannel(ParmBuf pbuf,int minRows);

static char * pbStatMap[] = { 
   "PB_INIT","PB_WAITING","PB_STOPPING","PB_FILLING","PB_STOPPED","PB_CLEARED" 
};

/* ChangeState: change state of buffer and trace if enabled */
static void ChangeState(ParmBuf pbuf, PBStatus newState)
{
   if (trace&T_PBS)
      printf("HParm:  %s -> %s\n",pbStatMap[pbuf->status],pbStatMap[newState]);
   pbuf->status = newState;
}

/* CheckBuffer: update status of given buffer */
static void CheckBuffer(ParmBuf pbuf)
{
   Boolean started=FALSE;  /* Speech detected */
   Boolean finished=FALSE; /* Silence detected */
   Boolean cleared=FALSE;  /* Source of data is clear */
   Boolean empty=FALSE;    /* ParmBuf is empty */
   
   if (pbuf->outRow==pbuf->spDetEn) empty=TRUE;
   if (pbuf->status>PB_INIT && pbuf->chClear) cleared=TRUE;
   if (pbuf->spDetEn<=pbuf->inRow) finished=TRUE;
   if (pbuf->spDetSt<=pbuf->inRow) started=TRUE;

   switch(pbuf->status){
   case PB_INIT:
      break;
   case PB_WAITING:
      if (started) ChangeState(pbuf,PB_STOPPING);
      else break;
   case PB_STOPPING:
      if (finished) ChangeState(pbuf,PB_STOPPED);
      break;
   case PB_FILLING:
      if (cleared) ChangeState(pbuf,PB_STOPPED);
      break;
   case PB_STOPPED:
      if (empty) {
         ChangeState(pbuf,PB_CLEARED);
         pbuf->lastRow=pbuf->outRow;
      }
      break;
   case PB_CLEARED:
      break;
   }
}

/* CheckAndFillBuffer: update status of given buffer and fill from channel */
static void CheckAndFillBuffer(ParmBuf pbuf)
{
   if (pbuf->status>PB_INIT && (pbuf->status < PB_STOPPED || 
                                pbuf->qen+pbuf->main.stRow<pbuf->spDetEn-1))
      FillBufFromChannel(pbuf,0);
   CheckBuffer(pbuf);
}

/* ------------------- Parameter Kind Conversions --------------- */

static char *pmkmap[] = {"WAVEFORM", "LPC", "LPREFC", "LPCEPSTRA", 
                         "LPDELCEP", "IREFC", 
                         "MFCC", "FBANK", "MELSPEC",
                         "USER", "DISCRETE", "PLP",
                         "ANON"};

/* EXPORT-> ParmKind2Str: convert given parm kind to string */
char *ParmKind2Str(ParmKind kind, char *buf)
{
   strcpy(buf,pmkmap[BaseParmKind(kind)]);
   if (HasEnergy(kind))    strcat(buf,"_E");
   if (HasDelta(kind))     strcat(buf,"_D");
   if (HasNulle(kind))     strcat(buf,"_N");
   if (HasAccs(kind))      strcat(buf,"_A");
   if (HasThird(kind))     strcat(buf,"_T");
   if (HasCompx(kind))     strcat(buf,"_C");
   if (HasCrcc(kind))      strcat(buf,"_K");
   if (HasZerom(kind))     strcat(buf,"_Z");
   if (HasZeroc(kind))     strcat(buf,"_0");
   if (HasVQ(kind))        strcat(buf,"_V");
   return buf;
}

/* EXPORT->Str2ParmKind: Convert string representation to ParmKind */
ParmKind Str2ParmKind(char *str)
{
   ParmKind i = -1;
   char *s,buf[255];
   Boolean hasE,hasD,hasN,hasA,hasT,hasF,hasC,hasK,hasZ,has0,hasV,found;
   int len;
   
   hasV=hasE=hasD=hasN=hasA=hasT=hasF=hasC=hasK=hasZ=has0=FALSE;
   strcpy(buf,str); len=strlen(buf);
   s=buf+len-2;
   while (len>2 && *s=='_') {
      switch(*(s+1)){
      case 'E': hasE = TRUE; break;
      case 'D': hasD = TRUE; break;
      case 'N': hasN = TRUE; break;
      case 'A': hasA = TRUE; break;
      case 'C': hasC = TRUE; break;
      case 'T': hasT = TRUE; break;
      case 'F': hasF = TRUE; break;
      case 'K': hasK = TRUE; break;
      case 'Z': hasZ = TRUE; break;
      case '0': has0 = TRUE; break;
      case 'V': hasV = TRUE; break;
      default: HError(6370,"Str2ParmKind: unknown ParmKind qualifier %s",str);
      }
      *s = '\0'; len -= 2; s -= 2;
   }
   found = FALSE;
   do {
      s=pmkmap[++i]; 
      if (strcmp(buf,s) == 0) {
         found = TRUE;
         break;
      }
   } while (strcmp("ANON",s)!=0);
   if (!found)
      return ANON;
   if (i == LPDELCEP)         /* for backward compatibility with V1.2 */
      i = LPCEPSTRA | HASDELTA;
   if (hasE) i |= HASENERGY;
   if (hasD) i |= HASDELTA;
   if (hasN) i |= HASNULLE;
   if (hasA) i |= HASACCS;
   if (hasT) i |= HASTHIRD;
   if (hasK) i |= HASCRCC;
   if (hasC) i |= HASCOMPX;
   if (hasZ) i |= HASZEROM;
   if (has0) i |= HASZEROC;
   if (hasV) i |= HASVQ;
   if(trace&T_BUF){
      fprintf(stdout,"ParmKind is %d\n",i);
      fflush(stdout);
   }
   return i;
}

/* EXPORT->BaseParmKind: return the basic sample kind without qualifiers */
ParmKind BaseParmKind(ParmKind kind) { return kind & BASEMASK; }

/* EXPORT->HasXXXX: returns true if XXXX included in ParmKind */
Boolean HasEnergy(ParmKind kind){return (kind & HASENERGY) != 0;}
Boolean HasDelta(ParmKind kind) {return (kind & HASDELTA) != 0;}
Boolean HasAccs(ParmKind kind)  {return (kind & HASACCS) != 0;}
Boolean HasThird(ParmKind kind) {return (kind & HASTHIRD) != 0;}
Boolean HasNulle(ParmKind kind) {return (kind & HASNULLE) != 0;}
Boolean HasCompx(ParmKind kind) {return (kind & HASCOMPX) != 0;}
Boolean HasCrcc(ParmKind kind)  {return (kind & HASCRCC) != 0;}
Boolean HasZerom(ParmKind kind) {return (kind & HASZEROM) != 0;}
Boolean HasZeroc(ParmKind kind) {return (kind & HASZEROC) != 0;}
Boolean HasVQ(ParmKind kind)    {return (kind & HASVQ) != 0;}

/* EXPORT->SyncBuffers: if matrix transformations are used this syncs the two buffers */
Boolean SyncBuffers(ParmBuf pbuf,ParmBuf pbuf2)
{
   int pref1=0, pref2=0, postf1=0, postf2=0;
   int preshift, postshift;
   float *fptr;

   if ((pbuf->cf->MatTranFN == NULL) && (pbuf2->cf->MatTranFN == NULL))
      return(TRUE);

   if (pbuf->cf->MatTranFN != NULL) {
      pref1 = pbuf->cf->preFrames; 
      postf1 = pbuf->cf->postFrames; 
   }
   if (pbuf2->cf->MatTranFN != NULL) {
      pref2 = pbuf2->cf->preFrames; 
      postf2 = pbuf2->cf->postFrames; 
   }
   preshift = pref1-pref2;
   postshift = postf1-postf2;

   if ((preshift == 0) && (postshift == 0))
      return(TRUE);

   if (preshift>0) { /* need to offset the start of buffer2 */
      fptr = pbuf2->main.data;
      fptr += (preshift * pbuf2->cf->nCols);
      pbuf2->main.data = fptr;
      pbuf2->main.nRows -= preshift;
      if (trace&T_MAT) 
         printf("HParm: Removing first %d frames from Buffer2 (%d floats)\n",preshift,(preshift * pbuf2->cf->nCols));
   } else {
      fptr = pbuf->main.data;
      fptr -= (preshift * pbuf->cf->nCols);
      pbuf->main.data = fptr;
      pbuf->main.nRows += preshift;
      if (trace&T_MAT) 
         printf("HParm: Removing first %d frames from Buffer1 (%d floats)\n",-preshift,-(preshift * pbuf->cf->nCols));
   }

   if (postshift>0) {
      pbuf2->main.nRows -= postshift;
      if (trace&T_MAT) 
         printf("HParm: Removing last %d frames from Buffer2\n",postshift);
   } else {
      pbuf->main.nRows += postshift;
      if (trace&T_MAT) 
         printf("HParm: Removing last %d frames from Buffer1\n",-postshift);
   }

   return(TRUE);
}


/* Apply the global feature transform */
static void ApplyStaticMat(IOConfig cf, float *data, Matrix trans, int vSize, int n, int step, int offset)
{
   float *fp,*fp1;
   int i,j,k,l,mrows,mcols,nframes,fsize,m;
   Vector *odata,tmp;

   mrows = NumRows(trans); mcols = NumCols(trans);
   nframes = 1 + cf->preFrames + cf->postFrames;
   fsize = cf->nUsed;
   odata = New(&gstack,nframes*sizeof(Vector));
   odata--;
   fp = data-1;
   for (i=1;i<=nframes;i++)
      odata[i] = CreateVector(&gstack,fsize);
   for (i=2;i<=nframes;i++) {
      for (j=1;j<=fsize;j++)
         odata[i][j] = fp[j];
      fp += vSize;
   }
   fp1 = data-1;

   if ((fsize*nframes) != mcols)
      HError(-1,"Incorrect number of elements (%d %d)",cf->nUsed ,mcols);
   for (i=1;i<=n-nframes+1;i++){
      tmp = odata[1];
      for (j=1;j<=nframes-1;j++)
         odata[j] = odata[j+1];
      odata[nframes] = tmp;
      for (j=1;j<=fsize;j++){
         tmp[j]=fp[j];
      }
      for (j=1;j<=mrows;j++) {
         fp++; fp1++; *fp1=0; m=0;
         for(l=1;l<=nframes;l++) {
            for (k=1;k<=fsize;k++) {
               m++;
               *fp1 += trans[j][m]*odata[l][k];
            }
         }
      }
      fp += vSize-mrows;
      fp1 += vSize-mrows;
   }
   Dispose(&gstack,odata+1);
   cf->nUsed = mrows;
}

/* ---------------- Data Sizing and Memory allocation --------------- */

/* MakeIOConfig: Create an IOConfig object.  Initial values are copied
   from defCon and then updated from configuration parameters */
static IOConfig MakeIOConfig(MemHeap *x,ChannelInfo *chan)
{
   IOConfig p;
   
   p = (IOConfig)New(x,sizeof(IOConfigRec));
   *p = chan->cf;
   return p;
}

/* SetCodeStyle: set the coding style in given cf */
static void SetCodeStyle(IOConfig cf)
{
   ParmKind tgt = cf->tgtPK&BASEMASK;
   char buf[MAXSTRLEN];
   
   switch (tgt) {
   case LPC: case LPREFC: case LPCEPSTRA:
      cf->style = LPCbased;
      break;
   case MELSPEC: case FBANK: case MFCC: case PLP:
      cf->style = FFTbased;
      break;
   case DISCRETE:
      cf->style = VQbased;
      break;
   default:
      HError(6321,"SetCodeStyle: Unknown style %s",ParmKind2Str(tgt,buf));
   }
}

/* ValidCodeParms: check to ensure reasonable wave->parm code params */
static void ValidCodeParms(IOConfig cf)
{
   int order=0;
   ParmKind btgt = cf->tgtPK&BASEMASK;
   
   if (cf->srcSampRate<=0.0 || cf->srcSampRate>10000000.0)
      HError(6371,"ValidCodeParms: src frame rate %f unlikely",cf->srcSampRate);
   if (cf->tgtSampRate<=cf->srcSampRate || cf->tgtSampRate>10000000.0)
      HError(6371,"ValidCodeParms: parm frame rate %f unlikely",cf->tgtSampRate);
   if (cf->winDur<cf->tgtSampRate || cf->winDur>cf->tgtSampRate*100.0)
      HError(6371,"ValidCodeParms: window duration %f unlikely",cf->winDur);
   if (cf->preEmph<0.0 || cf->preEmph>1.0)
      HError(6371,"ValidCodeParms: preEmph %f illegal",cf->preEmph);
   SetCodeStyle(cf);  /* in case not set yet */