feat_calc.cpp

Intel开发的IPP库的应用实例

/*
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 1999-2006 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives Gaussian Mixture Sample for Windows*
//
//  By downloading and installing this sample, you hereby agree that the
//  accompanying Materials are being provided to you under the terms and
//  conditions of the End User License Agreement for the Intel(R) Integrated
//  Performance Primitives product previously accepted by you. Please refer
//  to the file ippEULA.rtf located in the root directory of your Intel(R) IPP
//  product installation for more information.
//
//
//
//     Feature Calculation Class
//
*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ipps.h>
#include <ippsr.h>

#include "feat_calc.h"

Feat_Calc::Feat_Calc(int mf, int F, int L) {
   mean_factor   = mf;
   space_dim     = F;
   max_delay     = L;
   frame_number  = 0;
   space_dim4    = 0;
   raw_dim       = 0;
   delta_delay   = 0;
   var_norm      = false;
   cut_energy    = false;
   rem           = 0;
   deltas        = 0;
   feat_type     = -1;
   ready         = -2;
   raw           = NULL;
   mean          = NULL;
   oldraw        = NULL;
   curraw        = NULL;
   featmul       = NULL;
   pindx         = NULL;
   ready         = -2;
}

int Feat_Calc::Init_Feat(int N) {

   if (ready!=-2)               return -10;

   if (space_dim<=0)            return -1;
   frame_number = N;
   if (frame_number<=1)         return -1;
   rem=frame_number;
   if (space_dim<=0)            return -1;
   space_dim4=(space_dim+3)&(~3);
   if (max_delay<=0)            max_delay=IPP_MAX_32S;

   if (!(featmul = ippsMalloc_16s(space_dim4)))            return -2;
   ippsSet_16s((short)(1<<14),featmul,space_dim4);

   deltas      = 0;
   delta_delay = 0;
   feat_type   = 0;

   ready       = 0;
   return 0;
}

static FILE* create_feat_file(char *file, int frame_number, int len, int type, int period) {
   Feat_Header header;
   FILE *fptr=NULL;
   float* tmp_raw;
   int tmp_raw_dim;
   int i;

   if (!(fptr=fopen(file, "wb")))  return fptr;
   header.frames=frame_number;
   header.period=period;
   header.len=len;
   header.type=type;

   tmp_raw_dim=header.len>>2;

   if (fwrite((void*)(&header), sizeof(Feat_Header), 1, fptr)<1) {
      fclose(fptr); return fptr;
   }
   tmp_raw =(float*)calloc(sizeof(float),frame_number*tmp_raw_dim);
   if(!tmp_raw){
      fclose(fptr); return fptr;
   }

   for (i=0; i<(frame_number*tmp_raw_dim); i++) {
       tmp_raw[i]=-30.0f+((float)(rand())*60.0f/(float)RAND_MAX); // -30.0 ... 30.0
   }

   if (fwrite((void*)(tmp_raw), sizeof(float), frame_number*tmp_raw_dim, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(tmp_raw);

   fclose(fptr);
   fptr=fopen(file, "rb");
   return fptr;
}

int Feat_Calc::Init_Feat(char *file) {

   FILE  *fptr;
   cut_energy=false;
   int i;

   if (space_dim<=0)                                          return -1;
   if (!(fptr=fopen(file, "rb")))
        if (!(fptr=create_feat_file(file,517,52,70,100000))) return -3;
   if (fread(&header, sizeof (Feat_Header), 1, fptr)<1)       return -3;

   frame_number = header.frames;
   if (frame_number<=0)                                       return -1;
   rem=frame_number;
   if (space_dim<=0)                                          return -1;
   space_dim4=(space_dim+3)&(~3);
   if (max_delay<=0)          max_delay=IPP_MAX_32S;
   if (header.len&3!=0)                                       return -1;
   raw_dim=header.len>>2;

   if (!(pindx = ippsMalloc_32s(space_dim)))                  return -2;
   for (i=0; i<space_dim; i++) pindx[i]=i;
   if (space_dim%raw_dim==0) {    // use energy, process all phrase, do CMS and VN
      cut_energy=false;
      var_norm  =true;
      deltas=space_dim/raw_dim-1;
   } else if((space_dim%(raw_dim-1)==0)) {
      cut_energy=true;
      var_norm  =false;
      deltas=space_dim/(raw_dim-1)-1;
   } else {
                                                              return -1;
   }

   if (deltas==2) {
      delta_delay=(deltas+1)*WIN_SIZE;
   } else if (deltas==1) {
      delta_delay=(deltas+1)*WIN_SIZE;
   } else if (deltas==0) {
      delta_delay=0;
   } else {
                                                              return -1;
   }

   float *float_raw, *float_curraw;
   if (!(float_raw  = ippsMalloc_32f(frame_number*raw_dim)))  return -2;
   if (!(raw  = ippsMalloc_16s(frame_number*raw_dim))) {
      ippsFree(float_raw); return -2;
   }
   float_curraw = float_raw;
   for (i=0; i<frame_number; i++) {
      if ((int)fread(float_curraw,sizeof(float),raw_dim,fptr)<raw_dim) {
         fclose(fptr); ippsFree(float_raw); return -3;
      }

      float_curraw+=raw_dim-cut_energy;
   }
   raw_dim-=cut_energy;
   fclose(fptr);

   ippsConvert_32f16s_Sfs(float_raw,raw,frame_number*raw_dim,ippRndNear,
      -mean_factor);
//   ippsFree(float_raw);

   if (!cut_energy) {
      oldraw=raw;
      raw=NULL;
      if (!(raw  = ippsMalloc_16s(frame_number*space_dim4)))  return -2;
      ippsZero_16s(raw,frame_number*space_dim4);
      if (deltas==2) {
         ippsDeltaDelta_Win2_16s_D2Sfs(oldraw,raw_dim,raw,space_dim4,frame_number,
            (short)1,(short)1,IPP_DELTA_BEGIN|IPP_DELTA_END,3);
      } else if (deltas==1) {
         ippsDelta_Win2_16s_D2Sfs(oldraw,raw_dim,raw,space_dim4,frame_number,(short)1,
                                 IPP_DELTA_BEGIN|IPP_DELTA_END,0);
      } else {
         ippsCopyColumn_Indirect_16s_D2(oldraw,raw_dim,raw_dim,raw,pindx,raw_dim,
                                     space_dim4,frame_number);
      }
      ippsFree(oldraw);
      oldraw=NULL;

// cepstral mean subtraction and variance normalization for all phrase
      if (!(mean  = ippsMalloc_16s(6*space_dim4)))            return -2;
      short *var = mean+space_dim4;
      int *intvar = (int*)(var+space_dim4);
      int order;
      ippsMeanVarColumn_16s16s32s_D2(raw,frame_number,space_dim4,mean,
         intvar,space_dim);
      ippsRecSqrt_32s16s_Sfs(intvar,var,space_dim,1,-mean_factor);
      ippsMaxOrder_16s(var,space_dim,&order);
      int var_factor=mean_factor+14-order;
      int odd_add=0;
      if (mean_factor&1) {
         ippsLShiftC_32s_I(1,intvar,space_dim);
         odd_add=1;
      }
      ippsRecSqrt_32s16s_Sfs(intvar,var,space_dim,1,-var_factor-odd_add);
      ippsNormalizeColumn_16s_D2Sfs(raw,space_dim4,frame_number,mean,var,space_dim,
         var_factor-(mean_factor>>1));

      deltas=0;
      delta_delay=0;
      raw_dim=space_dim4;
   }

   if (!(featmul = ippsMalloc_16s(space_dim4)))               return -2;
   if (deltas==0) {
      ippsSet_16s(1<<14,featmul,space_dim4);
   } else if (deltas==1) {
      ippsSet_16s(1<<14,featmul,raw_dim);
      ippsSet_16s(((1<<14)+5)/10,featmul+raw_dim,space_dim4-raw_dim);
   } else {
      ippsSet_16s(1<<14,featmul,raw_dim);
      ippsSet_16s(((1<<14)+5)/10,featmul+raw_dim,raw_dim);
      ippsSet_16s(((1<<14)+5)/10,featmul+raw_dim+raw_dim,space_dim4-raw_dim-raw_dim);
   }

   curraw    = raw;
   feat_type = 1;

   ready     = 0;
   return 0;
}

int  Feat_Calc::Write_LogHeader(FILE *flog) {

   if (ready!=0)                return -10;

   header.len = space_dim*sizeof(float);
   if (flog)
      fwrite((void*)&header, sizeof(Feat_Header), 1, flog);

   return 0;

}

Feat_Calc::~Feat_Calc(void) {
   mean_factor   = 0;
   frame_number  = 0;
   max_delay     = 0;
   space_dim     = 0;
   space_dim4    = 0;
   raw_dim       = 0;
   delta_delay   = 0;
   var_norm      = false;
   cut_energy    = false;
   rem           = 0;
   deltas        = 0;
   feat_type     = -1;
   if (raw)      ippsFree(raw);
   if (mean)     ippsFree(mean);
   if (oldraw)   ippsFree(oldraw);
   if (featmul)  ippsFree(featmul);
   if (pindx)    ippsFree(pindx);
   raw           = NULL;
   mean          = NULL;
   oldraw        = NULL;
   curraw        = NULL;
   featmul       = NULL;
   pindx         = NULL;
   ready         = -2;
}

bool Feat_Calc::Set_Scale(int factor) {
   if (ready!=0)                                      return false;
   mean_factor=factor;
   return true;
}

bool Feat_Calc::Set_Delta(short *mul, int factor) {
   if (ready!=0)                                      return false;
   mul_factor=factor;
   ippsCopy_16s(mul,featmul,space_dim);
// prepare factor array for ipp DeltaMul functions
// DeltaMul used if last feature element (energy) is not used
   if (deltas==2) {
      ippsDiv_16s_ISfs(featmul+raw_dim,featmul+raw_dim+raw_dim,raw_dim,-mul_factor);
      ippsDiv_16s_ISfs(featmul,featmul+raw_dim,raw_dim,-mul_factor);
   } else if (deltas==1) {
      ippsDiv_16s_ISfs(featmul,featmul+raw_dim,raw_dim,-mul_factor);
   }
   return true;
}

int Feat_Calc::Get_Feature(short *dst, int len, bool* end) {

   int i;

   if (len>max_delay)
      len=max_delay;

   int arglen=len,outlen=len;

   if ((rem<=0)||(len<=0)||(ready<0)) {
      outlen=0;
   }

   if (feat_type==0) {

      if (len>=rem) {
         arglen=outlen=rem;
         rem=0;
      } else {
         rem-=outlen;
      }
      ippsZero_16s(dst,arglen*space_dim4);

   } else if (feat_type==1) {

      int delta_mode;       // mode for delta calculation
      if (rem==frame_number) {
         if (len>=rem) {
            arglen=outlen=rem;
            rem=0;
            delta_mode=IPP_DELTA_BEGIN|IPP_DELTA_END;
         } else {
            outlen-=delta_delay;
            rem-=outlen;
            delta_mode=IPP_DELTA_BEGIN;
         }
      } else {
         if (len>=rem) {
            arglen=outlen=rem;
            arglen-=delta_delay;
            rem=0;
            delta_mode=IPP_DELTA_END;
         } else {
            arglen-=delta_delay;
            outlen-=delta_delay;
            rem-=outlen;
            delta_mode=0;
         }
      }
      /* Calculate float features with Mul deltas and then convert to shorts */
      if (deltas==2) {
         ippsDeltaDeltaMul_Win2_16s_D2Sfs(curraw,featmul,raw_dim,dst,space_dim4,arglen,
                                 delta_mode,mul_factor);
      } else if (deltas==1) {
         ippsDeltaMul_Win2_16s_D2Sfs(curraw,featmul,raw_dim,dst,space_dim4,arglen,
                                 delta_mode,mul_factor);
      } else if (raw_dim==space_dim4) {
         for (i=0; i<outlen; i++)
            ippsMul_16s_Sfs(featmul,curraw+i*space_dim4,dst+i*space_dim4,raw_dim,mul_factor);
      }
      curraw+=raw_dim*arglen;
   } else {
      rem=0;
      outlen=0;
   }

   end[0]=(rem<=0);
   return outlen;
}