encoder_main.c

Intel开发的IPP库的应用实例

    const IppLibraryVersion *ver;
    short *WaveBuffer,*workWaveBuffer;
    unsigned char *FeatBuff,*pVadBuff,*workVadBuff;
    AuroraEncoder *pCodec;
    int i,NumberSample,OutputStride;
    int repeat;
    FILE *f_csv;
    HTKHeader HTKHead;
    int countFrame,stepSample;
    int FrameShift,FrameLength;
    int size;
    int cbeg;
    int end;
    short sync = 0x784d;
    Ipp64u time_start;
    Ipp64u time_finish;
    Ipp64s time_work;
    double rt_time;
/*-----------------------*/
    ver = ippsGetLibVersion();
    printf("IPPS library used: %s  %d.%d.%d\n",ver->Name,
         ver->major,ver->minor,ver->majorBuild);
    ver = ippsrGetLibVersion();
    printf("IPPSR library used: %s  %d.%d.%d\n",ver->Name,
         ver->major,ver->minor,ver->majorBuild);

    vadname[0]='\0';
    if (!ParseCommLine (argc - 1, argv + 1)){
        fprintf (stderr, "\r\n    USAGE:");
        fprintf (stderr, "   %s [options] <infile> <outfile>\r\n", argv[0]);
        fprintf (stderr, "\r\n    OPTIONS:\r\n");
        fprintf (stderr, "     -f   freq      Sampling frequency in kHz (8,11,16)        16\r\n");
        fprintf (stderr, "     -c             Write performance line \r\n");
        fprintf (stderr, "     -s   XX        Number of repeat                            1\r\n");
        fprintf (stderr, "     -o type        Run encoder output parameter                f\r\n");
        fprintf (stderr, "                              ( f - feature file, \r\n");
        fprintf (stderr, "                                q - quantised file) \r\n");
        fprintf (stderr, "                                m - multiframe file) \r\n");
        fprintf (stderr, "                                w - wave file) \r\n");
        fprintf (stderr, "     -i type        Run encoder input parameter                 w\r\n");
        fprintf (stderr, "                              ( f - feature file, \r\n");
        fprintf (stderr, "                                w - wave file) \r\n");
        fprintf (stderr, "     -step XX       Step for testing                         100  \r\n");
        fprintf (stderr, "     -vad filename  VAD file \r\n");
        fprintf (stderr, "     -help          Help \r\n");

    }
    else{

       /*-------------------   ENCODER -----------------------------*/
           /*   Init Codec    */
           if (InitAuroraEncoder(&pCodec,SFrequency,EncoderIn,EncoderOut)==-1)return -1;
           switch(SFrequency){
           case(r8KHz):FrameLength = FRAME_LENGTH_8KHz; FrameShift = FRAME_SHIFT_8KHz;break;
           case(r11KHz):FrameLength = FRAME_LENGTH_8KHz; FrameShift = FRAME_SHIFT_8KHz;break;
           case(r16KHz):FrameLength = FRAME_LENGTH_16KHz; FrameShift = FRAME_SHIFT_16KHz;break;
           }
           /*   Allocate input buffer and read input file    */
           fseek(fpIn,0L,SEEK_END);
           SizeBuffer = ftell(fpIn);

           fseek(fpIn,0L,SEEK_SET);

           if (EncoderIn==WAVEFORM){
              WaveBuffer = ReadWaveFile(fpIn, &SizeBuffer);
              NumberSample = SizeBuffer;
              FrameCounter = (SizeBuffer - (FrameLength-FrameShift))/FrameShift;
              if (EncoderOut==FEATURE){
                 if(vadname[0]!='\0')
                    fpVAD = fopen(vadname,"wb");
              }
              pVadBuff = ippsMalloc_8u(FrameCounter);
           }else if (EncoderIn==FEATURE){
              fread (&HTKHead,sizeof(HTKHeader),1,fpIn );
              NumberSample = FrameCounter = HTKHead.SamplesNumber;

              WaveBuffer=(short*)ippsMalloc_8u(NumberSample*(NUM_CEP_COEFF +1)*sizeof(float));
              fread(WaveBuffer,sizeof(char),NumberSample*(NUM_CEP_COEFF +1)*sizeof(float),fpIn);

              pVadBuff = ippsMalloc_8u(NumberSample);
              ippsSet_8u(1,pVadBuff,NumberSample);
              fpVAD = fopen(vadname,"rb");
              if(fpVAD)
                 fread(pVadBuff,sizeof(char),NumberSample,fpVAD);
           }

           /* Allocate buffer for output   */
           if (EncoderOut==MULTIFRAME){
             FrameCounter = FrameCounter/24+2;
           }

             OutputStride=160;

           switch(EncoderOut){
           case(MULTIFRAME):
              OutputStride = NUM_MULTI_BYTE * sizeof(char);
              break;
           case(QUANTIZED):
              OutputStride = (NUM_CODEBOOK+1) * sizeof(char);
              break;
           case(FEATURE):
              OutputStride = (NUM_CEP_COEFF+1) * sizeof(float);
              break;
           }
           if(EncoderOut==WAVEFORM)
              FeatBuff= ippsMalloc_8u(SizeBuffer*sizeof(short));
           else{
              FeatBuff = ippsMalloc_8u (FrameCounter * OutputStride);
           }


           repeat = n_repeat;
           /*   Main loop for timing  */
           time_start = ippGetCpuClocks();
           while(n_repeat--){
               workWaveBuffer = WaveBuffer;
               workVadBuff = pVadBuff;
               countFrame=0;
               stepSample=stepTest;
               for (i=0; i<NumberSample;i+=stepSample){
                  if ((NumberSample-i <= stepSample) || NumberSample-i==0){ size = NumberSample-i;
                  end=1;
                  }
                  else{ size = stepSample;
                  end=0;
                  }
                  if (EncoderIn==WAVEFORM && EncoderOut==WAVEFORM){
                     countFrame+=ApplyAuroraEncoder_WW(pCodec,(short *)workWaveBuffer,size,
                         (short*)(FeatBuff+countFrame*OutputStride),end );
                  }
                  if (EncoderIn==WAVEFORM && EncoderOut==FEATURE){
                     countFrame+=ApplyAuroraEncoder_WF(pCodec,(short *)workWaveBuffer,size,
                         (float*)(FeatBuff+countFrame*OutputStride),pVadBuff,end );
                  }
                  if (EncoderIn==WAVEFORM && EncoderOut==MULTIFRAME){
                     countFrame+=ApplyAuroraEncoder_WM(pCodec,(short *)workWaveBuffer,size,
                         FeatBuff+countFrame*OutputStride,end );
                  }
                  if (EncoderIn==WAVEFORM && EncoderOut==QUANTIZED){
                     countFrame+=ApplyAuroraEncoder_WQ(pCodec,(short *)workWaveBuffer,size,
                         FeatBuff+countFrame*OutputStride,end );
                  }
                  if (EncoderIn==FEATURE && EncoderOut==MULTIFRAME){
                     countFrame+=ApplyAuroraEncoder_FM(pCodec,(float *)workWaveBuffer,workVadBuff,size,
                         FeatBuff+countFrame*OutputStride,end );
                  }
                  if (EncoderIn==FEATURE && EncoderOut==QUANTIZED){
                     countFrame+=ApplyAuroraEncoder_FQ(pCodec,(float *)workWaveBuffer,workVadBuff,size,
                         FeatBuff+countFrame*OutputStride,end );
                  }
                  if (EncoderIn==WAVEFORM){
                     workWaveBuffer+=stepSample;
                     workVadBuff+=stepSample;
                  }
                  else{
                     workWaveBuffer+=stepSample*(NUM_CEP_COEFF +1)*2;
                     workVadBuff+=stepSample;
                  }
               }
           }
           time_finish = ippGetCpuClocks();
           if(time_start < time_finish) time_work = (Ipp64s)(time_finish-time_start);
           else    time_work = (Ipp64s)(IPP_MAX_64S-time_finish+time_start);

           rt_time = (double)(time_work)/repeat/1000000.0/NumberSample*SamplingFrequency;
           /* Write output file */
           if (EncoderOut == FEATURE && EncoderIn == WAVEFORM){
               WriteHTKHeader (fpOut, countFrame);
               fwrite (FeatBuff, sizeof (float), countFrame * (NUM_CEP_COEFF+1), fpOut);
               if(fpVAD)fwrite (pVadBuff, sizeof(char), countFrame, fpVAD);
           }
           else if (EncoderOut == QUANTIZED){
              fwrite (FeatBuff, sizeof (char), countFrame * (NUM_CODEBOOK+1), fpOut);
           }
           else if (EncoderOut == MULTIFRAME){
              fwrite (FeatBuff, sizeof (char), countFrame * NUM_MULTI_BYTE, fpOut);
              fwrite(&sync, sizeof(short), 1, fpOut);

           }
           else if (EncoderOut == WAVEFORM){
              header.lenData = countFrame * 80 * 2;
              header.lenfile =  countFrame * 80 * 2 + sizeof(wWaveHeader);
              header.lenSampInCh = countFrame * 80;
              header.frec = 8000;
              SaveWaveFile(fpOut,(short*)FeatBuff);
           }

           if(WaveBuffer) ippsFree(WaveBuffer);
           if(pVadBuff) ippsFree(pVadBuff);
           if(FeatBuff) ippsFree(FeatBuff);

           /*  Release memory */
           ReleaseAuroraEncoder(pCodec);


       /*-----------  Output statistics  --------------------   */
       printf(" %d frames\n",countFrame);
       printf(" Speed %g (MHz)\n",rt_time);
       if (puttocsv) {
          if ( (f_csv = fopen("encoderspeed.csv", "r")) == NULL)cbeg=1;else cbeg=0;
          if ( (f_csv = fopen("encoderspeed.csv", "a")) == NULL) {
             printf("\nFile codecspeed.csv could not be open.\n");
          exit(5);
          }
          if (cbeg)fprintf(f_csv,"\nTypeApplication, Type EncoderIn, Type EncoderOut, Time(MHz), Sample,Frame,FreqFile kHz");
          if ((EncoderIn == WAVEFORM) && (EncoderOut == QUANTIZED) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, QUANTIZED, %4.2f, %d, %d, %d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == WAVEFORM) && (EncoderOut == WAVEFORM) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, WAVEFORM, %4.2f, %d, %d, %d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == WAVEFORM) &&  (EncoderOut == FEATURE) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, FEATURE, %4.2f,  %d, %d,%d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == WAVEFORM) &&  (EncoderOut == MULTIFRAME) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, MULTIFRAME, %4.2f,  %d, %d,%d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == FEATURE) && (EncoderOut == QUANTIZED) )
              fprintf(f_csv,"\nEncoder, FEATURE, QUANTIZED, %4.2f, %d, %d, %d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == FEATURE) &&  (EncoderOut == MULTIFRAME) )
              fprintf(f_csv,"\nEncoder, FEATURE, MULTIFRAME, %4.2f,  %d, %d,%d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);


          fclose(f_csv);
       }


       /* Close input and output files */
       if (fpIn)fclose (fpIn);
       if (fpOut)fclose (fpOut);
       if (fpVAD)fclose (fpVAD);

    }/*else*/


   return 0;
}