hrec.c

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

   psi->hset=hset;
   sprintf(name,"PRI-%d Heap",psid++);
   CreateHeap(&psi->heap,name,MSTAK,1,1.0,1000,8000);

   psi->max=MaxStatesInSet(hset)-1;

   psi->tBuf=(Token*) New(&psi->heap,(psi->max-1)*sizeof(Token));
   psi->tBuf-=2;

   psi->sBuf=(TokenSet*) New(&psi->heap,psi->max*sizeof(TokenSet));
   rtoks=(RelToken*) New(&psi->heap,psi->max*sizeof(RelToken)*MAX_TOKS);
   psi->sBuf-=1;
   for (i=0; i<psi->max; i++) {
      psi->sBuf[i+1].set=rtoks;rtoks+=MAX_TOKS;
      psi->sBuf[i+1].tok=null_token;
      psi->sBuf[i+1].n=0;
      psi->sBuf[i+1].set[0]=rmax;
   }

   psi->stHeapIdx=(short*) New(&psi->heap,(psi->max+1)*sizeof(short));
   for (i=0; i<=psi->max; i++) psi->stHeapIdx[i]=-1;
   psi->stHeapIdx[1]=0; /* For one state word end models */

   psi->ntr=hset->numTransP;
   psi->seIndexes=(short***) New(&psi->heap, sizeof(short**)*psi->ntr);
   psi->seIndexes--;
   for(i=1;i<=psi->ntr;i++) psi->seIndexes[i]=NULL;
   for (h=0; h<MACHASHSIZE; h++)
      for (q=hset->mtab[h]; q!=NULL; q=q->next) {
         if (q->type=='h') {
            hmm=(HLink)q->structure;
            n=hmm->numStates-1;
            psi->stHeapIdx[n]=0;
            CreateSEIndex(psi,hmm);
         }
      }
   psi->nsp=hset->numStates;
   psi->sPre=(PreComp*) New(&psi->heap, sizeof(PreComp)*psi->nsp);
   psi->sPre--;
   for(i=1,pre=psi->sPre+1;i<=psi->nsp;i++,pre++) pre->id=-1;
   if (hset->numSharedMix>0) {
      psi->mixShared=TRUE;
      psi->nmp=hset->numSharedMix;
      psi->mPre=(PreComp*) New(&psi->heap, sizeof(PreComp)*psi->nmp);
      psi->mPre--;
      for(i=1,pre=psi->mPre+1;i<=psi->nmp;i++,pre++) pre->id=-1;
   }
   else
      psi->mixShared=FALSE,psi->nmp=0,psi->mPre=NULL;

   for (n=1,i=0;n<=psi->max;n++)
      if (psi->stHeapIdx[n]>=0)
         psi->stHeapIdx[n]=i++;
   psi->stHeapNum=i;

   return(psi);
}

void FreePSetInfo(PSetInfo *psi)
{
   DeleteHeap(&psi->heap);
   Dispose(&gcheap,psi);
}

static void LatFromPaths(Path *path,int *ln,Lattice *lat)
{
   LNode *ne,*ns;
   LArc *la;
   Word nullwordId;
   NxtPath tmp,*pth;
   Align *align,*al,*pr;
   MLink ml;
   LabId labid,labpr = NULL;
   char buf[80];
   int i,frame;
   double prlk,dur,like,wp;

   nullwordId = GetWord(lat->voc,GetLabId("!NULL",FALSE),FALSE);

   tmp.prev=path->prev;
   tmp.like=path->like;
   tmp.chain=path->chain;
   tmp.lm=path->lm;

   ne=lat->lnodes-path->usage;
   ne->time=path->frame*lat->framedur;
   if (path->node->info.pron != NULL)
      ne->word=path->node->info.pron->word;
   else
      ne->word=nullwordId;
   ne->tag=path->node->tag;
   if (path->node->info.pron != NULL)
      ne->v=path->node->info.pron->pnum;
   else
      ne->v=1;
   ne->score=path->like;

   align=path->align;

   for(pth=&tmp;pth!=NULL;pth=pth->chain) {
      la=lat->larcs+(*ln)++;
      if (pth->prev){
         ns=lat->lnodes-pth->prev->usage,prlk=pth->prev->like;
      } else {
         ns=lat->lnodes,prlk=0.0;
      }
      la->start=ns;la->end=ne;
      if (ne->word==NULL || ne->word==nullwordId) /* no word or NULL node */
         wp=0.0;                   /* No penalty for current word */
      else wp=pri->wordpen;       /* Inc penalty for current word */
      la->aclike=pth->like-prlk-pth->lm*pri->scale-wp;
      if (path->node->info.pron != NULL) {
         la->aclike-=path->node->info.pron->prob*pri->pscale;
         la->prlike=path->node->info.pron->prob;
      }
      else
         la->prlike=0.0;
      la->lmlike=pth->lm;
      la->score=pth->like;
      la->farc=ns->foll;la->parc=ne->pred;
      ns->foll=ne->pred=la;
      
      if (pth->prev!=NULL && ns->word==NULL)
         LatFromPaths(pth->prev,ln,lat);

      if (align!=NULL) {
         i=0;
         for (al=align;al!=NULL;al=al->prev) 
            i++;
         la->nAlign=i;
         la->lAlign=(LAlign*) New(lat->heap,sizeof(LAlign)*i);
         frame=path->frame;pr=NULL;
         /* Allow for wp diff between path and align */
         like=path->like-pth->lm*pri->scale-wp; 
         for (al=align;al!=NULL;al=al->prev) {
            ml=FindMacroStruct(pri->psi->hset,'h',al->node->info.hmm);
            if (ml==NULL)
               HError(8520,"LatFromPaths: Cannot find hmm in hset");
            if (al->state<0) {
               if (pr==NULL) {
                  pr=al;
                  labpr=ml->id;
                  continue;
               }
               if (labpr==NULL)
                  HError(8522,"LatFromPaths: Align records out of order");
               dur=(pr->frame-al->frame)*lat->framedur;
               like=pr->like-al->like;
               pr=al;
               labid=labpr;
               labpr=ml->id;
            }
            else {
               if (pri->models)
                  sprintf(buf,"s%d",al->state);
               else
                  sprintf(buf,"%s[%d]",ml->id->name,al->state);
               labid=GetLabId(buf,TRUE);
               dur=(frame-al->frame)*lat->framedur,
                  like=like-al->like;
               frame=al->frame;
            }
            i--;
            la->lAlign[i].state=al->state;
            la->lAlign[i].label=labid;
            la->lAlign[i].dur=dur;
            la->lAlign[i].like=like;
            like=al->like;
         }
         if (pr!=NULL) {
            if (path->prev!=NULL)
               dur=(pr->frame-path->prev->frame)*lat->framedur,
                  like=pr->like-path->prev->like;
            else
               dur=pr->frame*lat->framedur,
                  like=pr->like;
            i--;
            la->lAlign[i].state=-1;
            la->lAlign[i].label=labpr;
            la->lAlign[i].dur=dur;
            la->lAlign[i].like=like;
         }
         align=NULL;
      }
   }
}


/* Number/count nodes (in path->usage field) and count links */
static void MarkPaths(Path *path,int *nn,int *nl)
{
   NxtPath *pth;

   if (path->usage>=0) {
      path->usage=-(*nn)++;
      (*nl)++;
      if (path->prev) MarkPaths(path->prev,nn,nl);
      for (pth=path->chain;pth!=NULL;pth=pth->chain) {
         (*nl)++;
         if (pth->prev) MarkPaths(pth->prev,nn,nl);
      }
   }
}

static Lattice *CreateLattice(MemHeap *heap,TokenSet *res,HTime framedur)
{
   Lattice *lat;
   RelToken *cur;
   Path path;
   WordPron pron;
   NxtPath rth[MAX_TOKS];
   int nn,nl,ln,i;
   NetNode node;

   pron.word=NULL;pron.pnum=0;pron.next=NULL;
   pron.outSym=NULL;pron.phones=NULL;pron.nphones=0;
   pron.prob=0.0;
   
   path.like=res->tok.like;
   path.lm=res->tok.lm;
   path.usage=0;
   path.align=res->tok.align;
   path.node=&node;
   path.node->tag=NULL;
   path.node->info.pron=&pron;
   path.frame=pri->frame;
   path.prev=res->tok.path;
   path.chain=NULL;
   if (res->n>1) {
      path.chain=rth+1;
      for (i=1,cur=res->set+1;i<res->n;i++,cur++) {
         rth[i].like=res->tok.like+cur->like;
         rth[i].lm=cur->lm;
         rth[i].prev=cur->path;
         rth[i].chain=NULL;
         rth[i-1].chain=rth+i;
      }
   }

   nn=1;nl=0;ln=0;
   MarkPaths(&path,&nn,&nl);

   lat=NewLattice(heap,nn,nl);
   lat->voc=pri->net->vocab;
   lat->lmscale=pri->scale;
   lat->wdpenalty=pri->wordpen;
   lat->prscale=pri->pscale;
   lat->framedur=framedur;

   lat->lnodes[0].time=0.0; lat->lnodes[0].word=NULL;
   lat->lnodes[0].tag=NULL;
   lat->lnodes[0].score=0.0;

   LatFromPaths(&path,&ln,lat);

#ifdef SANITY
   if (ln!=nl)
      HError(8522,"CreateLattice: Size mismatch (nl (%d) != ln (%d))",nl,ln);
#endif

   return(lat);
}

static void qcksrtM(float *array,int l,int r,int M)
{
   int i,j;
   float x,tmp;

   if (l>=r || l>M || r<M) return;
   x=array[(l+r)/2];i=l-1;j=r+1;
   do {
      do i++; while (array[i]>x);
      do j--; while (array[j]<x);
      if (i<j) {
         tmp=array[i];array[i]=array[j];array[j]=tmp;
      }
   }
   while(i<j);
   if (j<M) qcksrtM(array,j+1,r,M);
   else qcksrtM(array,l,j,M);
}

/* EXPORT->InitVRecInfo: initialise ready for recognition */
VRecInfo *InitVRecInfo(PSetInfo *psi,int nToks,Boolean models,Boolean states)
{
   VRecInfo *vri;
   PreComp *pre;
   int i,n;
   char name[80];
   static int prid=0;

   vri=(VRecInfo*) New(&gcheap,sizeof(VRecInfo));
   sprintf(name,"VRI-%d Heap",prid++);
   CreateHeap(&vri->heap,name,MSTAK,1,1.0,1000,8000);

   pri=(PRecInfo*) New(&vri->heap,sizeof(PRecInfo));
   vri->pri=pri;
   vri->pri->prid=prid;

#ifdef SANITY
   pri->ipos=0;
   pri->start_inst=NULL;
   pri->pnlen = pri->pylen = 0;
   pri->anlen = pri->aylen = 0;
#endif

   /* Reset readable parameters */
   vri->maxBeam=0;
   vri->genBeam=-LZERO;
   vri->wordBeam=-LZERO;
   vri->nBeam=-LZERO;
   vri->tmBeam=LZERO;
   vri->pCollThresh=1024;
   vri->aCollThresh=1024;

   /* Set up private parameters */
   pri->qsn=0;pri->qsa=NULL;
   pri->psi=NULL;
   pri->net=NULL;
   pri->scale=1.0;
   pri->wordpen=0.0;

   /* Could be in StartNetwork ?? */
   pri->states=states;pri->models=models;
   if (nToks<=1) pri->nToks=0;
   else if (nToks<=MAX_TOKS) pri->nToks=nToks;
   else pri->nToks=MAX_TOKS;

   /* SetUp heaps for recognition */

   /* Model set dependent */
   pri->psi=psi;
   /* pri->psi->sBuf[1].n=((pri->nToks>1)?1:0);  Needed every observation */
   for(i=1,pre=psi->sPre+1;i<=psi->nsp;i++,pre++) pre->id=-1;
   for(i=1,pre=psi->mPre+1;i<=psi->nmp;i++,pre++) pre->id=-1;

   pri->stHeap=(MemHeap *) New(&vri->heap,pri->psi->stHeapNum*sizeof(MemHeap));
   for (n=1;n<=pri->psi->max;n++) {
      if (pri->psi->stHeapIdx[n]>=0) {
         sprintf(name,"State Heap: numStates=%d",n);
         CreateHeap(pri->stHeap+pri->psi->stHeapIdx[n],name,
                    MHEAP,sizeof(TokenSet)*n,1.0,100,1600);
      }
   }

   /* nTok dependent */
   if (pri->nToks>1)
      CreateHeap(&pri->rTokHeap,"RelToken Heap",
                 MHEAP,sizeof(RelToken)*pri->nToks,1.0,200,1600);
   /* Non dependent */
   CreateHeap(&pri->instHeap,"NetInst Heap",
              MHEAP,sizeof(NetInst),1.0,200,1600);
   CreateHeap(&pri->rPthHeap,"NxtPath Heap",
              MHEAP,sizeof(NxtPath),1.0,200,1600);
   CreateHeap(&pri->pathHeap,"Path Heap",
              MHEAP,sizeof(Path),1.0,200,1600);
   CreateHeap(&pri->alignHeap,"Align Heap",
              MHEAP,sizeof(Align),1.0,200,3200);


   /* Now set up instances */

   pri->head.node=pri->tail.node=NULL;
   pri->head.state=pri->tail.state=NULL;
   pri->head.exit=pri->tail.exit=NULL;
   pri->head.wdlk=pri->tail.wdlk=LZERO;
   pri->head.max=pri->tail.max=LZERO;
   pri->head.knil=pri->tail.link=NULL;
   pri->head.link=&pri->tail;pri->tail.knil=&pri->head;

   pri->pYesRef.link=&pri->pYesTail;pri->pYesTail.knil=&pri->pYesRef;
   pri->pYesTail.link=pri->pYesRef.knil=NULL;pri->pYesTail.usage=-2;
   pri->pNoRef.link=&pri->pNoTail;pri->pNoTail.knil=&pri->pNoRef;
   pri->pNoTail.link=pri->pNoRef.knil=NULL;pri->pNoTail.usage=-2;
   pri->npth=pri->cpth=0;
   
   pri->aYesRef.link=&pri->aYesTail;pri->aYesTail.knil=&pri->aYesRef;
   pri->aYesTail.link=pri->aYesRef.knil=NULL;pri->aYesTail.usage=-2;
   pri->aNoRef.link=&pri->aNoTail;pri->aNoTail.knil=&pri->aNoRef;
   pri->aNoTail.link=pri->aNoRef.knil=NULL;pri->aNoTail.usage=-2;
   pri->nalign=pri->calign=0;

   return(vri);
}

/* EXPORT->DeleteVRecInfo: Finished with this recogniser */
void DeleteVRecInfo(VRecInfo *vri)
{
   PRecInfo *pri;
   int i;
   
   pri=vri->pri;

   for (i=0;i<pri->psi->stHeapNum;i++)
      DeleteHeap(pri->stHeap+i);
   if (pri->nToks>1)
      DeleteHeap(&pri->rTokHeap);
   DeleteHeap(&pri->instHeap);
   DeleteHeap(&pri->rPthHeap);
   DeleteHeap(&pri->pathHeap);
   DeleteHeap(&pri->alignHeap);
   DeleteHeap(&vri->heap);
   Dispose(&gcheap,vri);
}

/* EXPORT->BeginRecNet: initialise network ready for recognition */
void StartRecognition(VRecInfo *vri,Network *net,
                      float scale,LogFloat wordpen,float pscale)
{
   NetNode *node;
   NetInst *inst,*next;
   PreComp *pre;
   int i;

   pri=vri->pri;
   if (pri==NULL)
      HError(8570,"StartRecognition: Visible recognition info not initialised");
   /* pri->psi->sBuf[1].n=((pri->nToks>1)?1:0);  Only needed for Step1 */

   vri->noTokenSurvived=TRUE;
   pri->net=net;
   pri->scale=scale;
   pri->wordpen=wordpen;
   pri->pscale=pscale;
   /* Initialise the network and instances ready for first frame */
                       
   for (node=pri->net->chain;node!=NULL;node=node->chain) node->inst=NULL;
   pri->net->final.inst=pri->net->initial.inst=NULL;
   for(i=1,pre=pri->psi->sPre+1;i<=pri->psi->nsp;i++,pre++) pre->id=-1;
   for(i=1,pre=pri->psi->mPre+1;i<=pri->psi->nmp;i++,pre++) pre->id=-1;

   pri->tact=pri->nact=pri->frame=0;

   AttachInst(&pri->net->initial);
   inst=pri->net->initial.inst;
   inst->state->tok.like=inst->max=0.0;
   inst->state->tok.lm=0.0;
   inst->state->tok.path=NULL;
   inst->state->n=((pri->nToks>1)?1:0);

   vri->genMaxNode=vri->wordMaxNode=NULL;
   vri->genMaxTok=vri->wordMaxTok=null_token;
   pri->wordThresh=pri->genThresh=pri->nThresh=LSMALL;
   pri->genMaxNode=pri->wordMaxNode=NULL;
   pri->genMaxTok=pri->wordMaxTok=null_token;
   for (inst=pri->head.link;inst!=NULL && inst->node!=NULL;inst=next)
      if (inst->max<pri->genThresh) {