}
      WavFileClose(&wfInputParams);
      if(f_log) fclose(f_log);
      return FOPEN_FAIL;
   }
   if(clParams.timing) {
      lCallResult = Timing(&clParams, &wfInputParams, f_log);
      return lCallResult;
   }
   /*If input file in PCM format than encode else decode*/
   if((wfInputParams.waveFmt.nFormatTag==LINIAR_PCM)||
            (wfInputParams.waveFmt.nFormatTag==ALAW_PCM/*A-law*/)||
            (wfInputParams.waveFmt.nFormatTag==MULAW_PCM/*mu-law*/)) {
      encode = 1;
      PCMType = wfInputParams.waveFmt.nFormatTag;
      strcpy((char*)codec.codecName, clParams.codecName);
      codec.lIsVad = (clParams.Vad>0);
   } else {
      encode = 0;
      codec.lFormatTag = wfInputParams.waveFmt.nFormatTag;
      clParams.bitrate = wfInputParams.bitrate;
   }

   if(encode) {
      /*Load codec by name from command line*/
      lCallResult = LoadUSCCodecByName(&codec,f_log);
      if(lCallResult<0) {
         if(clParams.puttologfile) {
            fprintf(f_log,"Cannot find %s codec.\n",codec.codecName);
         } else {
            printf("Cannot find %s codec.\n",codec.codecName);
         }
         if(f_log) fclose(f_log);
         return LOAD_CODEC_FAIL;
      }
      /*Get USC codec params*/
      lCallResult = USCCodecGetInfo(&codec.uscParams);
      if(lCallResult<0) return USC_CALL_FAIL;
      /*Get its supported format details*/
      lCallResult = GetUSCCodecParamsByFormat(&codec,BY_NAME,(clParams.Vad>0),f_log);
      if(lCallResult<0) {
         if(clParams.puttologfile) {
            fprintf(f_log,"Cannot find %s codec format description.\n",codec.codecName);
         } else {
            printf("Cannot find %s codec format description.\n",codec.codecName);
         }
         if(f_log) fclose(f_log);
         return LOAD_CODEC_FAIL;
      }
   } else {
      /*Get its supported format details*/
      lCallResult = GetUSCCodecParamsByFormat(&codec,BY_FORMATTAG,0,f_log);
      if(lCallResult<0) {
         if(clParams.puttologfile) {
            fprintf(f_log,"Cannot find format description.\n");
         } else {
            printf("Cannot find format description.\n");
         }
         if(f_log) fclose(f_log);
         return LOAD_CODEC_FAIL;
      }
      /*Load codec by name from format description*/
      lCallResult = LoadUSCCodecByName(&codec,f_log);
      if(lCallResult<0) {
         if(clParams.puttologfile) {
            fprintf(f_log,"Cannot find %s codec.\n",codec.codecName);
         } else {
            printf("Cannot find %s codec.\n",codec.codecName);
         }
         if(f_log) fclose(f_log);
         return LOAD_CODEC_FAIL;
      }
      /*Get USC codec params*/
      lCallResult = USCCodecGetInfo(&codec.uscParams);
      if(lCallResult<0) return USC_CALL_FAIL;
   }
   /* Check sample_frequence, bitspersample and number of channels*/
   if(encode) {
      if(PCMType==LINIAR_PCM) {
         if(wfInputParams.waveFmt.nBitPerSample != codec.uscParams.pInfo.pcmType.bitPerSample) {
            if(clParams.puttologfile) {
               fprintf(f_log,"Bits per sample must be %d for the %s codec\n",
                  codec.uscParams.pInfo.pcmType.bitPerSample, codec.uscParams.pInfo.name);
            } else {
               printf("Bits per sample must be %d for the %s codec\n",
                  codec.uscParams.pInfo.pcmType.bitPerSample, codec.uscParams.pInfo.name);
            }
            if(f_log) fclose(f_log);
            return UNKNOWN_FORMAT;
         }
      } else {
         if(wfInputParams.waveFmt.nBitPerSample != 8) {
            if(clParams.puttologfile) {
               fprintf(f_log,"Bits per sample must be 8 for the A-Law/Mu-Law input file\n");
            } else {
               printf("Bits per sample must be 8 for the A-Law/Mu-Law input file\n");
            }
            if(f_log) fclose(f_log);
            return UNKNOWN_FORMAT;
         }
      }
      if(wfInputParams.waveFmt.nSamplesPerSec != codec.uscParams.pInfo.pcmType.sample_frequency) {
         if(clParams.puttologfile) {
            fprintf(f_log,"Must be %d samples per seconds for the %s codec\n",
               codec.uscParams.pInfo.pcmType.sample_frequency,
               codec.uscParams.pInfo.name);
         } else {
            printf("Must be %d samples per seconds for the %s codec\n",
               codec.uscParams.pInfo.pcmType.sample_frequency,
               codec.uscParams.pInfo.name);
         }
         if(f_log) fclose(f_log);
         return UNKNOWN_FORMAT;
      }
      if(wfInputParams.waveFmt.nChannels != 1) {
         if(clParams.puttologfile) {
            fprintf(f_log,"Input file must be mono\n");
         } else {
            printf("Input file must be mono\n");
         }
         if(f_log) fclose(f_log);
         return UNKNOWN_FORMAT;
      }
   }
   /*Initialize Wave File params*/
   InitWavFile(&wfOutputParams);
   if (!encode) {
      /*Output file is pcm*/
      wfOutputParams.waveFmt.nFormatTag = LINIAR_PCM;
      wfOutputParams.waveFmt.nBitPerSample = codec.uscParams.pInfo.pcmType.bitPerSample;
      if(clParams.nOutputPCMType==ALAW_PCM) {
         wfOutputParams.waveFmt.nFormatTag = ALAW_PCM;
         wfOutputParams.waveFmt.nBitPerSample = 8;
      } else if(clParams.nOutputPCMType==MULAW_PCM) {
         wfOutputParams.waveFmt.nFormatTag = MULAW_PCM;
         wfOutputParams.waveFmt.nBitPerSample = 8;
      }
   } else {
      wfOutputParams.waveFmt.nFormatTag = codec.lFormatTag;
      wfOutputParams.waveFmt.nBitPerSample = 0;
   }
   /*Open wave file and read its header*/
   lCallResult=OpenWavFile(&wfOutputParams, clParams.outputFileName, FILE_WRITE);
   if(lCallResult==-1) {
      if(clParams.puttologfile) {
         fprintf(f_log,"Cannot open %s file for writing\n",clParams.outputFileName);
      } else {
         printf("Cannot open %s file for writing\n",clParams.outputFileName);
      }
      if(f_log) fclose(f_log);
      return FOPEN_FAIL;
   }

   if(encode) {
      /*Set params for encode*/
      SetUSCEncoderParams(&codec.uscParams, &clParams);
   } else {
      /*Set params for decode*/
      SetUSCDecoderParams(&codec.uscParams, &clParams);
   }
   /*Alloc memory for the codec*/
   codec.uscParams.nChannels = wfInputParams.waveFmt.nChannels;
   lCallResult = USCCodecAlloc(&codec.uscParams, &clParams);
   if(lCallResult<0) return USC_CALL_FAIL;
   if(encode) {
      /*Init encoder*/
      lCallResult = USCEncoderInit(&codec.uscParams, &clParams);
   } else {
      /*Init decoder*/
      lCallResult = USCDecoderInit(&codec.uscParams, &clParams);
   }
   if(lCallResult<0) return USC_CALL_FAIL;
   /*Allocate memory for the input buffer. Size of input buffer is equal to the size of input file*/
   inputBuffer = (char *)ippsMalloc_8u(wfInputParams.DataSize);
   if(!inputBuffer) {
      if(clParams.puttologfile) {
         fprintf(f_log,"Cannot allocate %d bytes memory\n",wfInputParams.DataSize);
      } else {
         printf("Cannot allocate %d bytes memory\n",wfInputParams.DataSize);
      }
      if(f_log) fclose(f_log);
      return MEMORY_FAIL;
   }

   /*Allocate memory for the output buffer. Size of output buffer is equal to the size of 1 frame*/
   outputBuffer = (char *)ippsMalloc_8u(codec.uscParams.pInfo.framesize*wfInputParams.waveFmt.nChannels);
   if(!outputBuffer) {
      if(clParams.puttologfile) {
         fprintf(f_log,"Cannot allocate %d bytes memory\n",codec.uscParams.pInfo.framesize);
      } else {
         printf("Cannot allocate %d bytes memory\n",codec.uscParams.pInfo.framesize);
      }
      if(f_log) fclose(f_log);
      return MEMORY_FAIL;
   }

   /*Read data from the input file to the buffer*/
   WavFileRead(&wfInputParams, (void *)inputBuffer, wfInputParams.DataSize);
   if((encode)&&(PCMType > LINIAR_PCM)) {
      lCallResult = USC_CvtToLiniar(&codec.uscParams, PCMType, &inputBuffer, &wfInputParams.DataSize);
      if(lCallResult<0) return MEMORY_FAIL;
   }

   /*Set pointer to the start of the data*/

   measure_init(&measure);
   ProcessOneChannel(&codec, &wfOutputParams, inputBuffer, wfInputParams.DataSize,
                        outputBuffer, &duration, &currLen);
   measure_finish(&measure);
   spSeconds = (duration/(float)(codec.uscParams.pInfo.pcmType.bitPerSample>>3))/
                        (float)codec.uscParams.pInfo.pcmType.sample_frequency;
   if(clParams.puttologfile) {
      fprintf(f_log,"Proceeded %g sec of speech\n",spSeconds);
      measure_output(f_log, &measure, spSeconds, 1, clParams.optionReport);
   } else {
      printf("Proceeded %g sec of speech\n",spSeconds);
      measure_output(stdout, &measure, spSeconds, 1, clParams.optionReport);
   }

   OutputString2CSVFile(&clParams, &codec.uscParams.pInfo, spSeconds,measure.speed_in_mhz);

   /* Fill output file params*/
   wfOutputParams.waveFmt.nChannels = 1;
   wfOutputParams.waveFmt.nSamplesPerSec = codec.uscParams.pInfo.pcmType.sample_frequency;

   if (!encode) {
      /*Output file is pcm*/
      wfOutputParams.waveFmt.nBlockAlign = wfOutputParams.waveFmt.nChannels*(wfOutputParams.waveFmt.nBitPerSample>>3);
   } else {
      int nBlockAlign;
      wfOutputParams.bitrate = codec.uscParams.pInfo.params.modes.bitrate;
      /* Calc nBlockAlign of the current codec*/
      USCCodecGetSize(&codec.uscParams, codec.uscParams.pInfo.framesize, &nBlockAlign);
      wfOutputParams.waveFmt.nBlockAlign = (nBlockAlign+USCGetFrameHeaderSize())*wfOutputParams.waveFmt.nChannels;
   }

   /* Close input file*/
   WavFileClose(&wfInputParams);
   /* Write file header*/
   WavFileWriteHeader(&wfOutputParams);
   /* Close output file*/
   WavFileClose(&wfOutputParams);
   /*Free resources*/
   if(inputBuffer) ippsFree(inputBuffer);
   if(outputBuffer) ippsFree(outputBuffer);
   /*Free codec memory*/
   USCFree(&codec.uscParams);
   /* Close plug-ins*/
   FreeUSCSharedObjects(&codec);
   if(f_log) fclose(f_log);
   return 0;
}