hparm.c

隐马尔科夫模型工具箱

      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;
   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 */
   switch (cf->style){
   case LPCbased:
      order = cf->lpcOrder;
      if (order<2 || order>1000)
         HError(6371,"ValidCodeParms: unlikely lpc order %d",cf->lpcOrder);
      if (cf->tgtPK&HASZEROC)
         HError(6321,"ValidCodeParms: cannot have C0 with lpc");
      break;
   case FFTbased:
      order = cf->numChans;
      if (order<2 || order>1000)
         HError(6371,"ValidCodeParms: unlikely num channels %d",cf->numChans);
      if (cf->loFBankFreq > cf->hiFBankFreq || 
          cf->hiFBankFreq > 0.5E7/cf->srcSampRate)
         HError(6371,"ValidCodeParms: bad band-pass filter freqs %.1f .. %.1f",
                cf->loFBankFreq,cf->hiFBankFreq);
      if (btgt == PLP) {
         order = cf->lpcOrder;
         if (order < 2 || order > 1000)
            HError(6371,"ValidCodeParms: unlikely lpc order %d",cf->lpcOrder);
         if (!cf->usePower)
            HError(-6371,"ValidCodeParms: Using linear spectrum with PLP");
         if (cf->compressFact >= 1.0 || cf->compressFact <= 0.0)
            HError(6371,"ValidCodeParms: Compression factor (%f) should have a value between 0 and 1\n",cf->compressFact);
      }
      break;
   default: break;
   }
   if (btgt == LPCEPSTRA || btgt == MFCC || btgt == PLP){
      if (cf->numCepCoef < 2 || cf->numCepCoef > order)
         HError(6371,"ValidCodeParms: unlikely num cep coef %d",cf->numCepCoef);
      if (cf->cepLifter < 0 || cf->cepLifter > 1000)
         HError(6371,"ValidCodeParms: unlikely cep lifter %d",cf->cepLifter);
   }

   if (cf->warpFreq < 0.5 || cf->warpFreq > 2.0)
      HError (6371, "ValidCodeParms: unlikely warping factor %s\n", cf->warpFreq);
   if (cf->warpFreq != 1.0) {
      if (cf->warpLowerCutOff == 0.0 || cf->warpUpperCutOff == 0.0 ||
          cf->warpLowerCutOff > cf->warpUpperCutOff)
         HError (6371, "ValidCodeParms: invalid warping cut-off frequencies %f %f \n",
                 cf->warpLowerCutOff , cf->warpUpperCutOff);
      if (cf->warpUpperCutOff == 0.0 && cf->warpLowerCutOff != 0.0) {
         cf->warpUpperCutOff = cf->warpLowerCutOff;
         HError (-6371, "ValidCodeParms: setting warp cut-off frequencies to %f %f\n",
                 cf->warpLowerCutOff, cf->warpUpperCutOff);
      }
      if (cf->warpLowerCutOff == 0.0 && cf->warpUpperCutOff != 0.0) {
         cf->warpUpperCutOff = cf->warpLowerCutOff ;
         HError (-6371, "ValidCodeParms: setting warp cut-off frequencies to %f %f\n",
                 cf->warpLowerCutOff, cf->warpUpperCutOff);
      }
   }
}

/* EXPORT->ValidConversion: checks that src -> tgt conversion is possible */
Boolean ValidConversion (ParmKind src, ParmKind tgt)
{
   static short xmap[13][13] = {
      { 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0},    /* src = WAVEFORM */
      { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},    /* src = LPC */
      { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},    /* src = LPREFC */
      { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},    /* src = LPCEPSTRA */
      { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},    /* src = LPDELCEP */
      { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},    /* src = IREFC */
      { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},    /* src = MFCC */
      { 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0},    /* src = FBANK */