prob_calc.cpp

Intel开发的IPP库的应用实例

   sen_end      = false;
   type         = calcNone;
   if (features) ippsFree(features);
   if (tmp_prob) ippsFree(tmp_prob);
   if (buffer)   ippsFree(buffer);
   if (flog)     fclose(flog);
   feat         = NULL;
   buffer       = NULL;
   features     = NULL;
   tmp_prob     = NULL;
   states       = NULL;
   weights      = NULL;
   dets         = NULL;
   means        = NULL;
   vars         = NULL;
   curfeat      = NULL;
   endfeat      = NULL;
   lastfeat     = NULL;
   flog         = NULL;
   if(sel_gauss)
       delete sel_gauss;
   sel_gauss    = NULL;
   is_select    = false;
   ready        = -2;
}

bool Prob_Calc::Attach_Feat(Feat_Calc *f) {
   if (ready!=-1)                                      return false;
   feat=f;
   if (!feat)                                          return false;
   if (!feat->Ready())                                 return false;
   if (feat->Feature_Length()!=space_dim)              return false;

   sen_end     = false;
   curfeat     = features;
   endfeat     = features;
   lastfeat    = features;
   curidx      = 0;
   lastidx     = 0;
   delta_delay = feat->Delta_Delay();

   if (flog)
      feat->Write_LogHeader(flog);

   ready       = 0;
   return true;
}

bool Prob_Calc::Detach_Feat(void) {
   if (ready!=0)                                       return false;
   sen_end=true;
   feat=NULL;
   curfeat=NULL;
   endfeat=NULL;
   lastfeat=NULL;
   curidx=0;
   lastidx=0;
   delta_delay=0;
   ready=-1;

   if (flog)
      fclose(flog);
   flog=NULL;

   return true;
}

bool Prob_Calc::Step_Forward(void) {
   if (ready!=0)                                       return false;
   curfeat+=space_dim4;
   curidx++;
   if ((sen_end)&&(lastidx==curidx)) {
      return false;
   } else if (curidx>=max_len-min_len-delta_delay) {  //  switch to buffer beginning
      if (is_select) {
         sel_gauss->ShiftIndxBegin(delta_delay+(lastfeat-curfeat)/space_dim4);
      }
      ippsCopy_32f(curfeat,features,lastfeat-curfeat+delta_delay*space_dim4);
      lastfeat=features+(lastfeat-curfeat);
      lastidx=lastidx-curidx;
      curfeat=features;
      curidx=0;
   }
   return true;
}

int Prob_Calc::Obv_Prob_Vec(int state, float *result, int len) {
   int m,num;
   if (ready!=0)                                       return -1;
   if (!sen_end) {
      if (lastidx-curidx<min_len) {
         num=feat->Get_Feature(lastfeat,max_len-lastidx,&sen_end);
         if (flog)
            for (m=0; m<num; m++)
               fwrite((void*)(lastfeat+m*space_dim4), sizeof(float), space_dim, flog);
         // here wait if num==0 if features are consumed faster
         if (is_select) {
            if (lastidx==curidx)
               sel_gauss->WriteVQ(lastfeat, 0, num);
            else
               sel_gauss->WriteVQ(lastfeat, lastidx, num);
         }
         lastidx+=num;
         lastfeat+=num*space_dim4;
      }
   }

   num=lastidx-curidx;
   if (len<num) num=len;

   float *mean=Mean(state);
   float *var=Var(state);
   float *det=Det(state);
   float *feat=curfeat;

   switch (type) {
   case calcVecS:
          sel_gauss->FillSign(states[state].compNum, states[state].compInd, num, curidx);
          ippsLogGaussMixture_Select_32f_D2(curfeat, mean, var, space_dim4,
             space_dim, det, sel_gauss->MixTable, states[state].compNum, result, num, -4.31602e+008f);
      break;
   case calcVect:
          ippsLogGauss_32f_D2(curfeat,space_dim4,mean,var,space_dim,result,num,det[0]);
          for (m=1; m<states[state].compNum; m++) {
              mean+=space_dim4;
              var+=space_dim4;
              ippsLogGaussAdd_32f_D2(curfeat,space_dim4,mean,var,space_dim,result,num,det[m]);
          }
      break;
   case calcVecM:
      ippsLogGauss_32f_D2(curfeat,space_dim4,mean,var,space_dim,result,num,det[0]);
      for (m=1; m<states[state].compNum; m++) {
         mean+=space_dim4;
         var+=space_dim4;
         ippsLogGaussMax_32f_D2(curfeat,space_dim4,mean,var,space_dim,result,num,det[m]);
      }
      break;
   case calcMMix:
      for (m=0; m<num; m++) {
         ippsCopy_32f(det,tmp_prob,states[state].compNum);
         ippsLogGaussMultiMix_32f_D2(mean,var,space_dim4,feat,space_dim,
            tmp_prob,states[state].compNum);
         ippsLogSum_32f(tmp_prob,result+m,states[state].compNum,ippAlgHintNone);
         feat+=space_dim4;
      }
      break;
   case calcMix:
      for (m=0; m<num; m++) {
         ippsLogGaussMixture_32f_D2(feat,mean,var,states[state].compNum,space_dim4,
            space_dim,det,result+m);
         feat+=space_dim4;
      }
      break;
   case calcNone:
      fake_sum=det[0];
      for (m=0; m<space_dim4*states[state].compNum; m+=8)
         fake_sum+=mean[m];
      for (m=0; m<space_dim4*states[state].compNum; m+=8)
         fake_sum+=var[m];
      for (m=0; m<space_dim4*num; m+=8)
         fake_sum+=curfeat[m];
      break;
   default:
      return -1;
   }

   return num;
}


int Prob_Calc::ReadAndInitCdbk(char* file, int cdbksize, int num_clust, int num_vec, float val,
                               bool is_row){
   FILE  *fptr;
   Param_File_Header header;
   float *tmpcodebook,*tmpweights;
   int i;

   if (!(fptr=fopen(file, "rb")))
       return -3;

   if (fread((void*)(&header), sizeof(Param_File_Header), 1, fptr)<1) {
      fclose(fptr); return -3;
   }

// ******************** Reading codebook start ********************
     if ((header.fileType&0x1000)!=0) { //it means that codebook is stored in file
        if (fseek(fptr,sizeof(Param_File_Header)+sizeof(File_Mixture)*state_number+sizeof(float)*gauss_num+
           2*sizeof(float)*space_dim4*gauss_num+gauss_num*sizeof(float)+header.trpNum*sizeof(float),SEEK_SET)!=0){
           fclose(fptr); return -3;
        }

        i=-1;
        fread((void*)(&i), sizeof(int), 1, fptr);

        if (i==cdbksize) { // the same codebook
           if (!(tmpweights=ippsMalloc_32f(space_dim4*(cdbksize+1)))) {
              fclose(fptr); return -2;
           }
           tmpcodebook=tmpweights+space_dim4;

           if ((int)fread((void*)tmpweights, sizeof(float), space_dim4, fptr) < space_dim4) {
              ippsFree(tmpweights); fclose(fptr); return -3;
           }

           if ((int)fread((void*)tmpcodebook, sizeof(float)*space_dim4, cdbksize, fptr) < cdbksize) {
              ippsFree(tmpweights); fclose(fptr); return -3;
           }

           i=sel_gauss->Init_SelectGauss_Simple(max_len, max_gauss, gauss_num, tmpcodebook, tmpweights,
                                                means, states, state_number);
           if (i!=0) {
              ippsFree(tmpweights); fclose(fptr); return i;
           }

           ippsFree(tmpweights);
        }
     }
     fclose(fptr);
// ******************** Reading codebook end ********************
       return 0;
}

int Prob_Calc::CreateInitSaveCdbk(char* file, int cdbksize, int num_clust, int num_vec, float val, bool is_row){
   int i;
   FILE  *fptr;
   Param_File_Header header;
   float *tmpcodebook,*tmpweights;
   char *tmparray;
   int filesize;

   if (!(tmpweights=ippsMalloc_32f(space_dim4*(cdbksize+1)))) {
      return -2;
   }
   tmpcodebook=tmpweights+space_dim4;

// ******************** Creating codebook start ********************
   i=sel_gauss->Init_SelectGauss_Full(max_len, max_gauss, gauss_num, tmpcodebook, tmpweights, means,
                                      states, state_number);

   if (i!=0) {
      ippsFree(tmpweights); return i;
   }
// ******************** Creating codebook end ********************

// ******************** Saving codebook start ********************
   if (!(fptr=fopen(file, "rb"))) {
      ippsFree(tmpweights); return -3;
   }

   if (fread((void*)(&header), sizeof(Param_File_Header), 1, fptr)<1) {
      ippsFree(tmpweights); fclose(fptr); return -3;
   }

   if ((header.fileType&0x1000)!=0) { //it means that codebook exist in file, remove cdbk
      filesize=sizeof(File_Mixture)*state_number+sizeof(float)*gauss_num+2*sizeof(float)*space_dim4*gauss_num+gauss_num*sizeof(float)+header.trpNum*sizeof(float);
      if (!(tmparray=(char*)ippsMalloc_8u(filesize))) {
         ippsFree(tmpweights); fclose(fptr); return -2;
      }

      if ((int)fread((void*)tmparray, 1,filesize, fptr)<filesize) {
         ippsFree(tmpweights); ippsFree(tmparray); fclose(fptr); return -3;
      }
      fclose(fptr);

      if (!(fptr=fopen(file, "wb"))) {
         ippsFree(tmpweights); ippsFree(tmparray); fclose(fptr); return -3;
      }

      if ((int)fwrite((void*)(&header), sizeof(Param_File_Header), 1, fptr)<1) {
         ippsFree(tmpweights); ippsFree(tmparray); fclose(fptr); return -3;
      }

      if ((int)fwrite((void*)(tmparray), 1, filesize, fptr)<filesize) {
         ippsFree(tmpweights); ippsFree(tmparray); fclose(fptr); return -3;

      }
      fclose(fptr);
      ippsFree(tmparray);
   } else { //replace header only
      fclose(fptr);
      header.fileType|=0x1000;

      if (!(fptr=fopen(file, "r+b"))) {
         ippsFree(tmpweights); fclose(fptr); return -3;
        }

      if(fseek(fptr,0,SEEK_SET)!=0){
         ippsFree(tmpweights); fclose(fptr); return -3;
        }

      if ((int)fwrite((void*)(&header), sizeof(Param_File_Header), 1, fptr)<1) {
         ippsFree(tmpweights); fclose(fptr); return -3;
        }

      fclose(fptr);
   }

   // Adding codebook information!!!
   if (!(fptr=fopen(file, "ab"))) {
         ippsFree(tmpweights); fclose(fptr); return -3;
   }

   if ((int)fwrite((void*)(&cdbksize), sizeof(int), 1, fptr)<1) {
         ippsFree(tmpweights); fclose(fptr); return -3;
   }

   if ((int)fwrite((void*)tmpweights, sizeof(float), space_dim4, fptr)<space_dim4) {
         ippsFree(tmpweights); fclose(fptr); return -3;
   }

   if ((int)fwrite((void*)tmpcodebook, sizeof(float)*space_dim4, cdbksize, fptr)<cdbksize) {
         ippsFree(tmpweights); fclose(fptr); return -3;
   }
   fclose(fptr);

   ippsFree(tmpweights);
// ******************** Saving codebook end ********************
   return 0;
}

void Prob_Calc::Get_Statistics(Len_Stat *stat) {
// all     -  all Gaussian counter
// lost    -  calculated Gaussian counter
    if(sel_gauss){
        stat->all=sel_gauss->count_all;
        stat->lost=sel_gauss->count_one;
    }else{
        stat->all=0;
        stat->lost=0;
    }
}