player11.c

723 codec convert ,use intel ipp lib,it is ok

   strncpy( line, cmndline, linelen-1 );
   token = strtok( line, seps );          /* the first true argument */
   while( token != NULL && argc <= argvlen ) {
      argv[argc++] = token;
      token = strtok( NULL, seps );
   }
   return argc;
}

Ipp32s WINAPI WinMain( HINSTANCE hinst, HINSTANCE xxx, LPWSTR lpCmdLine, Ipp32s yyy )
{
   Ipp8s line[WINCE_CMDLINE_SIZE];                     /* to copy command line */
   Ipp8s* argvv[WINCE_NCMD_PARAMS];
   Ipp8s** argv=argvv;

   wchar_t wexename[WINCE_EXENAME_SIZE];
   Ipp8s exename[WINCE_EXENAME_SIZE];
   Ipp8s cmdline[WINCE_CMDLINE_SIZE];

   /* simulate argc and argv parameters */
   Ipp32s argc;
#else /*Other OS*/
Ipp32s main11(Ipp32s argc, Ipp8s *argv[])
{
#endif /*_WIN32_WCE*/
   Ipp32s lCallResult, encode;
   Ipp32s PCMType = -1;
   LoadedCodec codec;
   WaveFileParams wfInputParams;
   WaveFileParams wfOutputParams;
   CommandLineParams clParams;
   Ipp8s *inputBuffer=NULL;
   Ipp8s *outputBuffer=NULL;
   Ipp32s currLen, duration;
   const  IppLibraryVersion *verIppSC;
   Ipp32f spSeconds;
   FILE *f_log=NULL;
   int lCPUFreq;

#if defined( _WIN32_WCE )

   GetModuleFileName( hinst, wexename, WINCE_EXENAME_SIZE );
   sprintf( exename, "%ls", wexename );
   sprintf( cmdline, "%ls", lpCmdLine );
   argc = parseCmndLine( exename, cmdline, line, WINCE_CMDLINE_SIZE, argv, WINCE_NCMD_PARAMS );

#endif
   /*
      Dynamic re-linkage from PX to target IPP library,
      need only if codec was linked with ippmerged lib
   */

   ippStaticInit();

   SetCommandLineByDefault(&clParams);
   /*Get params from comman line.*/
   ReadCommandLine(&clParams, argc, argv);
   if(clParams.puttologfile) {
      f_log=fopen(clParams.logFileName,"a");
      if(f_log==NULL) {
         printf("Cannot open %s log file for writing\n",clParams.logFileName);
         printf("Log file ignored.\n");
         clParams.puttologfile = 0;
      }
   }

   if(clParams.optionReport) {
      verIppSC = ippscGetLibVersion();
      USC_OutputString(f_log, "%s\n",COPYRIGHT_STRING);
      USC_OutputString(f_log, "Intel Unified Speech Codec interface based console player\n");
      USC_OutputString(f_log, "The Intel(R) IPPSC library used:  %d.%d.%d Build %d, name %s\n",
             verIppSC->major,verIppSC->minor,verIppSC->majorBuild,verIppSC->build,verIppSC->Name);
   }

   if(clParams.enumerate) {
      EnumerateStaticLinkedCodecs(f_log);
      if(f_log) fclose(f_log);
      return 0;
   }

   if((!clParams.inputFileName[0]) ||(!clParams.outputFileName[0])) {
      PrintUsage();
      return 0;
   }
   /*Open inpuit file and read header*/
   InitWavFile(&wfInputParams);
   lCallResult = OpenWavFile(&wfInputParams, clParams.inputFileName, FILE_READ);
   if(lCallResult==-1) {
      USC_OutputString(f_log, "Cannot open %s file for reading\n",clParams.inputFileName);
      if(f_log) fclose(f_log);
      return FOPEN_FAIL;
   }
   /*Read WAVE file header*/
   lCallResult = WavFileReadHeader(&wfInputParams);
   if(lCallResult<0) {
      if(lCallResult==-1) USC_OutputString(f_log, "Couldn't read from the %s file\n",clParams.inputFileName);
      if(lCallResult==-2) USC_OutputString(f_log, "File %s isn't in RIFF format\n",clParams.inputFileName);
      if(lCallResult==-3) USC_OutputString(f_log, "File %s is in RIFF format but not in a WAVE foramt\n",
                                       clParams.inputFileName);;
      WavFileClose(&wfInputParams);
      if(f_log) fclose(f_log);
      return FOPEN_FAIL;
   }
   if(clParams.timing) {
      lCallResult = Timing(&clParams, &wfInputParams, f_log);
      return lCallResult;
   }

   USCClear(&codec.uscParams);

   /*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((Ipp8s*)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) {
         USC_OutputString(f_log, "Cannot find %s codec.\n",codec.codecName);
         if(f_log) fclose(f_log);
         return LOAD_CODEC_FAIL;
      }
      /*Get USC codec params*/
      lCallResult = USCCodecAllocInfo(&codec.uscParams);
      if(lCallResult<0) return USC_CALL_FAIL;
      lCallResult = USCCodecGetInfo(&codec.uscParams);
      if(lCallResult<0) return USC_CALL_FAIL;
      /*Get its supported format details*/
      lCallResult = GetUSCCodecParamsByFormat(&codec,BY_NAME,f_log);
      if(lCallResult<0) {
         USC_OutputString(f_log, "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,f_log);
      if(lCallResult<0) {
         USC_OutputString(f_log, "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) {
         USC_OutputString(f_log, "Cannot find %s codec.\n",codec.codecName);
         if(f_log) fclose(f_log);
         return LOAD_CODEC_FAIL;
      }
      /*Get USC codec params*/
      lCallResult = USCCodecAllocInfo(&codec.uscParams);
      if(lCallResult<0) return USC_CALL_FAIL;
      lCallResult = USCCodecGetInfo(&codec.uscParams);
      if(lCallResult<0) return USC_CALL_FAIL;
   }
   /* Check sample_frequence, bitspersample and number of channels*/
   if(encode) {
      USC_PCMType streamType;
      streamType.bitPerSample = wfInputParams.waveFmt.nBitPerSample;
      streamType.nChannels = wfInputParams.waveFmt.nChannels;
      streamType.sample_frequency = wfInputParams.waveFmt.nSamplesPerSec;

      lCallResult = SetUSCEncoderPCMType(&codec.uscParams, PCMType, &streamType, f_log);
      if(lCallResult < 0) {
         USC_OutputString(f_log, "Unsupported PCM type: %d bps, %d channels %d sample freq by %s codec\n",
               streamType.bitPerSample,streamType.nChannels,streamType.sample_frequency, codec.uscParams.pInfo->name);
         if(f_log) fclose(f_log);
         return UNKNOWN_FORMAT;
      }
   } else {
      USC_PCMType streamType;
      streamType.bitPerSample = wfInputParams.waveFmt.nBitPerSample;
      streamType.nChannels = wfInputParams.waveFmt.nChannels;
      streamType.sample_frequency = wfInputParams.waveFmt.nSamplesPerSec;

      lCallResult = SetUSCDecoderPCMType(&codec.uscParams, PCMType, &streamType, f_log);
      if(lCallResult < 0) {
         USC_OutputString(f_log, "Unsupported PCM type: %d bps, %d channels %d sample freq by %s codec\n",
               streamType.bitPerSample,streamType.nChannels,streamType.sample_frequency, codec.uscParams.pInfo->name);
         if(f_log) fclose(f_log);
         return UNKNOWN_FORMAT;
      }
   }

   if(encode) {
      /*Set params for encode*/
      SetUSCEncoderParams(&codec.uscParams, &clParams);
   } else {
      /*Set params for decode*/
      SetUSCDecoderParams(&codec.uscParams, &clParams);
   }
   /*Alloc memory for the codec*/
   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;

   /*Initialize Wave File params*/
   InitWavFile(&wfOutputParams);
   if (!encode) {
      /*Output file is pcm*/
      wfOutputParams.waveFmt.nFormatTag = LINIAR_PCM;
      wfOutputParams.waveFmt.nBitPerSample = (Ipp16s)codec.uscParams.pInfo->params.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 = (Ipp16s)codec.lFormatTag;
      wfOutputParams.waveFmt.nBitPerSample = 0;
   }
   /*Open output wave file*/
   lCallResult=OpenWavFile(&wfOutputParams, clParams.outputFileName, FILE_WRITE);
   if(lCallResult==-1) {
      USC_OutputString(f_log, "Cannot open %s file for writing\n",clParams.outputFileName);
      if(f_log) fclose(f_log);
      return FOPEN_FAIL;
   }

   /*Allocate memory for the input buffer. Size of input buffer is equal to the size of input file*/
   inputBuffer = (Ipp8s *)ippsMalloc_8u(wfInputParams.DataSize);
   if(!inputBuffer) {
      USC_OutputString(f_log, "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 = (Ipp8s *)ippsMalloc_8u(codec.uscParams.pInfo->params.framesize);
   if(!outputBuffer) {
      USC_OutputString(f_log, "Cannot allocate %d bytes memory\n",codec.uscParams.pInfo->params.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, (Ipp32s*)&wfInputParams.DataSize);
      if(lCallResult<0) return MEMORY_FAIL;
   }

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

   vm_time_open(&handle);
   vm_time_init(&measure);
   ProcessOneChannel(&codec, &wfOutputParams, inputBuffer, wfInputParams.DataSize,
                        outputBuffer, &duration, &currLen);

   spSeconds = (duration/(Ipp32f)(codec.uscParams.pInfo->params.pcmType.bitPerSample>>3))/
                        (Ipp32f)codec.uscParams.pInfo->params.pcmType.sample_frequency;

   if(f_log) {
      fprintf(f_log,"Proceeded %g sec of speech\n",spSeconds);
   } else {
      printf("Proceeded %g sec of speech\n",spSeconds);
   }

#if defined( _WIN32_WCE )
   lCPUFreq = 400;
#else
   ippGetCpuFreqMhz(&lCPUFreq);
#endif

   if(clParams.puttologfile) {
      fprintf(f_log,"%4.2f MHz per channel\n",(Ipp32f)(dTime/spSeconds)*(Ipp32f)lCPUFreq);
   } else {
      printf("%4.2f MHz per channel\n",(Ipp32f)(dTime/spSeconds)*(Ipp32f)lCPUFreq);
   }

   OutputString2CSVFile(&clParams, codec.uscParams.pInfo, spSeconds,(Ipp32f)dTime/spSeconds*(Ipp32f)lCPUFreq);

   vm_time_close(&handle);

   /* Fill output file params*/
   wfOutputParams.waveFmt.nChannels = (Ipp16s)codec.uscParams.pInfo->params.pcmType.nChannels;
   wfOutputParams.waveFmt.nSamplesPerSec = codec.uscParams.pInfo->params.pcmType.sample_frequency;

   if (!encode) {
      /*Output file is pcm*/
      wfOutputParams.waveFmt.nBlockAlign = wfOutputParams.waveFmt.nChannels*(wfOutputParams.waveFmt.nBitPerSample>>3);
   } else {
      Ipp32s nBlockAlign;
      wfOutputParams.bitrate = codec.uscParams.pInfo->params.modes.bitrate;
      /* Calc nBlockAlign of the current codec*/
      USCCodecGetSize(&codec.uscParams, codec.uscParams.pInfo->params.framesize, &nBlockAlign);
      wfOutputParams.waveFmt.nBlockAlign = (Ipp16s)((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;
}