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 F, int L) {
   space_dim     = F;
   max_delay     = L;
   frame_number  = 0;
   space_dim4    = 0;
   raw_dim       = 0;
   delta_delay   = 0;
   rem           = 0;
   deltas        = 0;
   feat_type     = -1;
   ready         = -2;
   raw           = NULL;
   mean          = NULL;
   oldraw        = NULL;
   curraw        = 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;

   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;
   bool 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;
      deltas=space_dim/raw_dim-1;
   } else if((space_dim%(raw_dim-1)==0)) {
      cut_energy=true;
      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;
   }

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

   if (!cut_energy) {
      oldraw=raw;
      raw=NULL;
      if (!(raw  = ippsMalloc_32f(frame_number*space_dim4)))  return -2;
      if (deltas==2) {
         ippsDeltaDelta_Win2_32f_D2(oldraw,raw_dim,raw,space_dim4,frame_number,0.1f,0.1f,
                                 IPP_DELTA_BEGIN|IPP_DELTA_END);
      } else if (deltas==1) {
         ippsDelta_Win2_32f_D2(oldraw,raw_dim,raw,space_dim4,frame_number,0.1f,
                                 IPP_DELTA_BEGIN|IPP_DELTA_END);
      } else {
         ippsCopyColumn_Indirect_32f_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_32f(2*space_dim4)))            return -2;
      float *var = mean+space_dim4;
      ippsMeanVarColumn_32f_D2(raw,frame_number,space_dim4,mean,var,space_dim);
      ippsRecSqrt_32f(var,space_dim,1.0e-8f);
      ippsNormalizeColumn_32f_D2(raw,space_dim4,frame_number,mean,var,space_dim);

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

   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) {
   frame_number  = 0;
   max_delay     = 0;
   space_dim     = 0;
   space_dim4    = 0;
   raw_dim       = 0;
   delta_delay   = 0;
   rem           = 0;
   deltas        = 0;
   feat_type     = -1;
   if (raw)      ippsFree(raw);
   if (mean)     ippsFree(mean);
   if (oldraw)   ippsFree(oldraw);
   if (pindx)    ippsFree(pindx);
   raw           = NULL;
   mean          = NULL;
   oldraw        = NULL;
   curraw        = NULL;
   pindx         = NULL;
   ready         = -2;
}

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

   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_32f(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;
         }
      }

      if (deltas==2) {
         ippsDeltaDelta_Win2_32f_D2(curraw,raw_dim,dst,space_dim4,arglen,0.1f,0.1f,
                                 delta_mode);
      } else if (deltas==1) {
         ippsDelta_Win2_32f_D2(curraw,raw_dim,dst,space_dim4,arglen,0.1f,delta_mode);
      } else if (raw_dim==space_dim4) {
         ippsCopy_32f(curraw,dst,raw_dim*outlen);
      } else {
         ippsCopyColumn_Indirect_32f_D2(curraw,raw_dim,raw_dim,dst,pindx,raw_dim,
                                     space_dim4,outlen);
      }
      curraw+=raw_dim*arglen;

   } else {
      rem=0;
      outlen=0;
   }

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