/*
//
//                  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) 2003-2006 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives Aurora 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.
//
//  ES 201 108 v1.1.3 is the international standard promoted by ETSI
//   and other organizations. Implementations of these standards, or the standard
//   enabled platforms may require licenses from various entities, including
//  Intel Corporation.
//
*/

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <math.h>

#include "encoderapi.h"


#define BOOLEAN int
#define FALSE 0
#define TRUE (!FALSE)

int n_repeat;
AuroraDataType EncoderOut;
AuroraDataType EncoderIn;

FILE *fpIn = NULL;
FILE *fpOut = NULL;

AuroraRate SFrequency = r16KHz; /* SamplingFrequency */
int SamplingFrequency = 16000;  /* SamplingFrequency */
int puttocsv = 0;
int stepTest=100;

typedef struct{
    long SamplesNumber;
    long SamplePeriod;
    short SampleSize;
    short SampleKind;
}
HTKHeader;

void WriteHTKHeader (FILE * out, int SamplesNumber){
    long tmpl[2];
    short tmps[2];
    fseek (out, 0L, SEEK_SET);
    tmpl[0] = SamplesNumber; tmpl[1] = 100000;
    tmps[0] = (short)(NUM_CEP_COEFF + 1 )*4; tmps[1] = 8262;

    fwrite (tmpl, sizeof (long), 2, out);
    fwrite (tmps, sizeof (short), 2, out);
}

void ReadWave (FILE *fpIn, short *Buffer, int size ){
  short s;
  int i;
  for ( i=0; i<size; i++ )
    {
    fread (&s, sizeof (short), 1, fpIn);
    if (1) s = ((s & 0x00ff) << 8) | ((s & 0xff00) >> 8);
    Buffer[i]=(short)s;
    }
}
static BOOLEAN
ParseCommLine (int argc, char *argv[])
{
    int rep;
    n_repeat = 1;
    if (argc < 2) return FALSE;
    EncoderOut = FEATURE;
    EncoderIn = WAVEFORM;
    while (argc-2)
    {
        if(strcmp(*argv,"-o")==0){
            if(strcmp(*(argv+1),"f")==0)
               EncoderOut = FEATURE;
            else if(strcmp(*(argv+1),"m")==0)
               EncoderOut = MULTIFRAME;
            else if(strcmp(*(argv+1),"q")==0)
               EncoderOut = QUANTIZED;
            argc-=2;
            argv+=2;
            continue;
        }
        if(strcmp(*argv,"-i")==0){
            if(strcmp(*(argv+1),"f")==0)
               EncoderIn = FEATURE;
            else if(strcmp(*(argv+1),"w")==0)
               EncoderIn = WAVEFORM;
            argc-=2;
            argv+=2;
            continue;
        }
        else if(strcmp(*argv,"-step")==0){
            rep = atoi(*(argv+1));
            if(0 == rep) rep=1;
            stepTest=rep;
            argc-=2;
            argv+=2;
            continue;
        }
        else if(strcmp(*argv,"-s")==0){
            rep = atoi(*(argv+1));
            if(0 == rep) rep=1;
            if(rep > n_repeat) n_repeat=rep;
            argc-=2;
            argv+=2;
            continue;
        }
        else if (strcmp (*argv, "-f") == 0)
        {
            SamplingFrequency = 1000 * atoi (*(argv+1));
            switch(SamplingFrequency){
            case 16000: SFrequency = r16KHz;break;
            case 11000: SFrequency = r11KHz;break;
            case 8000: SFrequency = r8KHz;break;
            default:
                 printf("WARNING:unrecognised frequancy %s \n",*(argv+1));
                 return FALSE;
            }
            argc-=2;
            argv+=2;
            continue;
        }
        else if (strcmp (*argv, "-c") == 0)
        {
            puttocsv = 1;
            argc--;
            argv++;
            continue;
        }
        printf("WARNING:unrecognised parameter %s \n",*argv);
        argc--;
        argv++;
        return FALSE;
    }
    if ( (fpIn = fopen(*argv, "rb")) == NULL) {
        printf("File %s could not be open.\n", *argv);
         return FALSE;
    }
    argv++; argc--;
    if ( (fpOut = fopen(*argv, "wb")) == NULL) {
        printf("File %s could not be open.\n", *argv);
         return FALSE;
    }
    argv++; argc--;

    return TRUE;
}



int main(int argc, char *argv[] ){
/*-----------------------*/

    Ipp64u m_clocks;

    long  FrameCounter = 0,SizeBuffer;

    const IppLibraryVersion *ver;
    short *WaveBuffer,*workWaveBuffer;
    unsigned char *FeatBuff;
    AuroraEncoder *pCodec;
    int i,NumberSample;
    int repeat;
    FILE *f_csv;
    HTKHeader HTKHeader;
    int countFrame,stepSample,OutputStride;
    int FrameShift,FrameLength;
    int size;
    int cbeg;
    int end;
    short sync = 0x784d;
    clock_t time_start;
    clock_t time_finish;
    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);

    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 \r\n");
        fprintf (stderr, "     -o type      Run encoder output parameter \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, "     -i type      Run encoder input parameter \r\n");
        fprintf (stderr, "                              ( f - feature file, \r\n");
        fprintf (stderr, "                                w - wave file) \r\n");
        fprintf (stderr, "     -step XX     Step for testing  \r\n");

    }
    else{

       /*-------------------   ENCODER -----------------------------*/
           /*   Init Codec    */
           if (InitAuroraEncoder(&pCodec,SFrequency,EncoderIn,EncoderOut)==-1)return -1;
           switch(SFrequency){
           case(r8KHz):FrameLength = FRAME_LEN_8; FrameShift = FRAME_SHIFT_8;break;
           case(r11KHz):FrameLength = FRAME_LEN_11; FrameShift = FRAME_SHIFT_11;break;
           case(r16KHz):FrameLength = FRAME_LEN_16; FrameShift = FRAME_SHIFT_16;break;
           }

           /*   Read wave file    */
           fseek(fpIn,0L,SEEK_END);
           SizeBuffer = ftell(fpIn);

           fseek(fpIn,0L,SEEK_SET);
           if (EncoderIn==WAVEFORM){
              SizeBuffer=SizeBuffer-56;
              fseek(fpIn,56L,SEEK_SET);
              SizeBuffer=(SizeBuffer>>1);
              NumberSample = SizeBuffer;
              WaveBuffer=ippsMalloc_16s(SizeBuffer);
              ReadWave(fpIn, WaveBuffer,SizeBuffer);
              FrameCounter = (SizeBuffer - (FrameLength-FrameShift))/FrameShift;
           }else if (EncoderIn==FEATURE){
              fread (&HTKHeader,sizeof(HTKHeader),1,fpIn );
              NumberSample = FrameCounter = HTKHeader.SamplesNumber;

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

           /* Allocate buffer for output feature  */
           if (EncoderOut==MULTIFRAME){
             FrameCounter = FrameCounter/24+2;
           }
           switch(EncoderOut){
           case(MULTIFRAME):
              OutputStride = NUM_MULTY_BYTE * sizeof(char);
              break;
           case(QUANTIZED):
              OutputStride = NUM_CODEBOOK * sizeof(char);
              break;
           case(FEATURE):
              OutputStride = (NUM_CEP_COEFF+1) * sizeof(short);
              break;
           }

           FeatBuff = ippsMalloc_8u (FrameCounter * OutputStride);

           m_clocks=ippGetCpuClocks();
           repeat = n_repeat;

           /*   Main loop for timing  */
           time_start = clock();
           while(n_repeat--){
               workWaveBuffer = WaveBuffer;
               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==FEATURE){
                     countFrame+=ApplyAuroraEncoder_WF(pCodec,(short *)workWaveBuffer,size,
                         (short*)(FeatBuff+countFrame*OutputStride),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,(short *)workWaveBuffer,size,
                         FeatBuff+countFrame*OutputStride,end );
                  }
                  if (EncoderIn==FEATURE && EncoderOut==QUANTIZED){
                     countFrame+=ApplyAuroraEncoder_FQ(pCodec,(short *)workWaveBuffer,size,
                         FeatBuff+countFrame*OutputStride,end );
                  }
                  workWaveBuffer+=stepSample;
               }
           }

           time_finish = clock();
           rt_time = (double)(time_finish-time_start)/CLOCKS_PER_SEC/repeat*1000;
           /* Write Feature file */
           if (EncoderOut == FEATURE){

               WriteHTKHeader (fpOut, countFrame);

               fwrite (FeatBuff, sizeof (short), countFrame * (NUM_CEP_COEFF+1), fpOut);
           }
           else if (EncoderOut == QUANTIZED){
               fwrite (FeatBuff, sizeof (char), countFrame * NUM_CODEBOOK, fpOut);
           }
           else if (EncoderOut == MULTIFRAME){
               fwrite (FeatBuff, sizeof (char), countFrame * NUM_MULTY_BYTE, fpOut);
               fwrite(&sync, sizeof(short), 1, fpOut);

           }


           if(FeatBuff) ippsFree(FeatBuff);
           if(WaveBuffer) ippsFree(WaveBuffer);
           /*  Release memory */
           ReleaseAuroraEncoder(pCodec);

       /*-----------  Output statistics  --------------------   */
       printf(" %d frames\n",countFrame);
       printf(" Speed %g (ms)\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(ms), Sample,Frame,FreqFile kHz");
          if ((EncoderIn == WAVEFORM) && (EncoderOut == QUANTIZED) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, QUANTIZED, %f, %d, %d, %d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == WAVEFORM) &&  (EncoderOut == FEATURE) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, FEATURE, %f,  %d, %d,%d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == WAVEFORM) &&  (EncoderOut == MULTIFRAME) )
              fprintf(f_csv,"\nEncoder, WAVEFORM, MULTIFRAME, %f,  %d, %d,%d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == FEATURE) && (EncoderOut == QUANTIZED) )
              fprintf(f_csv,"\nEncoder, FEATURE, QUANTIZED, %f, %d, %d, %d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
          if ((EncoderIn == FEATURE) &&  (EncoderOut == MULTIFRAME) )
              fprintf(f_csv,"\nEncoder, FEATURE, MULTIFRAME, %f,  %d, %d,%d",rt_time,
              NumberSample,countFrame,(int)SamplingFrequency/1000);
       }


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

    }/*else*/


   return 0;
}