sound.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 Speech Processing 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.
//
*/

#include <windows.h>
#include "sound.h"

Sound *pSound;
LPWAVEHDR dw;

/**** Copy Datas to big buffre ****/
void CopyBuffer(){
   if ( (pSound->m_nEndBuffer + (int)dw->dwBytesRecorded) > pSound->m_nSizeBigBuffer){
      int Size = (pSound->m_nEndBuffer + (int)dw->dwBytesRecorded) - pSound->m_nSizeBigBuffer;
      int Add = (int)dw->dwBytesRecorded - Size;
      ippsCopy_8u((const unsigned char *)dw->lpData,pSound->m_pBufferOut+pSound->m_nEndBuffer,Add);
      ippsCopy_8u((const unsigned char *)(dw->lpData+Add),pSound->m_pBufferOut,Size);
      pSound->m_nEndBuffer = Size;
   }
   else {
      ippsCopy_8u((const unsigned char *)dw->lpData,pSound->m_pBufferOut+pSound->m_nEndBuffer,dw->dwBytesRecorded);
      pSound->m_nEndBuffer += (int)dw->dwBytesRecorded;
   }
   pSound->m_nCountSample+=dw->dwBytesRecorded;
}

/**** Read data from small buffer ****/
void CALLBACK WaveInProc(HWAVEIN hwi,UINT uMsg,         
                         DWORD dwInstance, DWORD dwParam1, DWORD dwParam2){
    switch(uMsg) {
      case WIM_OPEN:
      break;
      case WIM_DATA:
       dw = (LPWAVEHDR)dwParam1;
       if(pSound->m_bReset){
           if(pSound->m_nfirst==1){
               pSound->m_nfirst = 2;
               MMRESULT status= waveInAddBuffer(pSound->m_hWaveIn,&pSound->m_wavehdr1,sizeof(WAVEHDR));
           }else if(pSound->m_nfirst==2){
               pSound->m_nfirst = 3;
               MMRESULT status= waveInAddBuffer(pSound->m_hWaveIn,&pSound->m_wavehdr2,sizeof(WAVEHDR));
           }else if(pSound->m_nfirst==3){
               pSound->m_nfirst = 4;
               MMRESULT status= waveInAddBuffer(pSound->m_hWaveIn,&pSound->m_wavehdr3,sizeof(WAVEHDR));
           }else if(pSound->m_nfirst==4){
               pSound->m_nfirst = 1;
               MMRESULT status= waveInAddBuffer(pSound->m_hWaveIn,&pSound->m_wavehdr4,sizeof(WAVEHDR));
           }
       }
       CopyBuffer();
      break;
      case WIM_CLOSE:
      break;
    }
    return;
};

/**** end thread function ******/

Sound::Sound(int SampleRate){
   m_nSampleRate = SampleRate;
   m_nChannels = 1;
   m_nSamplesPerSec = SampleRate;
   m_wBitsPerSample = 16;

   m_pBuffer2=ippsMalloc_8u(BLOCKSIZE);
   m_pBuffer1=ippsMalloc_8u(BLOCKSIZE);
   m_pBuffer3=ippsMalloc_8u(BLOCKSIZE);
   m_pBuffer4=ippsMalloc_8u(BLOCKSIZE);

   m_pBufferOut = NULL;
   m_nCountSample=0;
   pSound=this;
 
   m_bReset=false;
};

Sound::~Sound(){
   MMRESULT status = MMSYSERR_NOERROR;
   status = waveInUnprepareHeader( m_hWaveIn, &m_wavehdr1, sizeof(WAVEHDR)); 
   status = waveInUnprepareHeader( m_hWaveIn, &m_wavehdr2, sizeof(WAVEHDR)); 
   status = waveInUnprepareHeader( m_hWaveIn, &m_wavehdr3, sizeof(WAVEHDR)); 
   status = waveInUnprepareHeader( m_hWaveIn, &m_wavehdr4, sizeof(WAVEHDR)); 

   status |= waveInClose(m_hWaveIn);

   if(m_pBufferOut)ippsFree(m_pBufferOut);
   if(m_pBuffer1)ippsFree(m_pBuffer1);
   if(m_pBuffer2)ippsFree(m_pBuffer2);
   if(m_pBuffer3)ippsFree(m_pBuffer3);
   if(m_pBuffer4)ippsFree(m_pBuffer4);
}

/**** Open Sound Card for read data ****/
MMRESULT Sound::OpenSoundDevice(void){
   MMRESULT status = MMSYSERR_NODRIVER;

   WAVEFORMATEX waveformat;
    waveformat.nChannels = m_nChannels;
    waveformat.nSamplesPerSec = m_nSamplesPerSec; 
    waveformat.wBitsPerSample = m_wBitsPerSample;
    waveformat.wFormatTag = WAVE_FORMAT_PCM; 
    waveformat.nBlockAlign = m_nChannels * m_wBitsPerSample / 8; 
    waveformat.nAvgBytesPerSec = m_nSamplesPerSec * waveformat.nBlockAlign; 
   waveformat.cbSize=sizeof(WAVEFORMATEX);

    WAVEINCAPS wavecaps;
   status = waveInGetDevCaps(0,&wavecaps,sizeof(WAVEINCAPS));
   if(status!=MMSYSERR_NOERROR)return status;

   status = waveInOpen(&m_hWaveIn,0,&waveformat,(DWORD)WaveInProc,0,
      CALLBACK_FUNCTION|WAVE_ALLOWSYNC);
   if(status!=MMSYSERR_NOERROR)return status;

   m_wavehdr1.lpNext = 0; 
    m_wavehdr1.lpData = (char*)m_pBuffer1;
    m_wavehdr1.dwBufferLength = BLOCKSIZE; 
    m_wavehdr1.dwFlags = 0; 
    m_wavehdr1.dwUser = 0;
    m_wavehdr1.dwLoops =0;
    m_wavehdr1.dwBytesRecorded = 0;

   m_wavehdr2.lpNext = 0; 
    m_wavehdr2.lpData = (char*)m_pBuffer2;
    m_wavehdr2.dwBufferLength = BLOCKSIZE; 
    m_wavehdr2.dwFlags = 0; 
    m_wavehdr2.dwUser = 0;
    m_wavehdr2.dwLoops =0;
    m_wavehdr2.dwBytesRecorded = 0;

   m_wavehdr3.lpNext = 0; 
    m_wavehdr3.lpData = (char*)m_pBuffer3;
    m_wavehdr3.dwBufferLength = BLOCKSIZE; 
    m_wavehdr3.dwFlags = 0; 
    m_wavehdr3.dwUser = 0;
    m_wavehdr3.dwLoops =0;
    m_wavehdr3.dwBytesRecorded = 0;

   m_wavehdr4.lpNext = 0; 
    m_wavehdr4.lpData = (char*)m_pBuffer4;
    m_wavehdr4.dwBufferLength = BLOCKSIZE; 
    m_wavehdr4.dwFlags = 0; 
    m_wavehdr4.dwUser = 0;
    m_wavehdr4.dwLoops =0;
    m_wavehdr4.dwBytesRecorded = 0;


   m_nSizeBigBuffer = 160*1000*2*50;
   m_pBufferOut=ippsMalloc_8u(m_nSizeBigBuffer);


   if(m_pBuffer1==NULL || m_pBuffer2==NULL || m_pBuffer3==NULL || m_pBuffer4==NULL || m_pBufferOut==NULL)
      return MMSYSERR_ALLOCATED;

   return MMSYSERR_NOERROR;
}
/**** Start record speech ****/
MMRESULT Sound::RecordSound(void){
   MMRESULT status = MMSYSERR_NOERROR;
   pSound = this;

   m_wavehdr1.dwBytesRecorded = 0;
   m_wavehdr2.dwBytesRecorded = 0;
   m_wavehdr3.dwBytesRecorded = 0;
   m_wavehdr4.dwBytesRecorded = 0;

   status = waveInPrepareHeader(m_hWaveIn,&m_wavehdr1,sizeof(WAVEHDR));   
   if(status!=MMSYSERR_NOERROR)
      return status;

   status = waveInPrepareHeader(m_hWaveIn,&m_wavehdr2,sizeof(WAVEHDR));   
   if(status!=MMSYSERR_NOERROR)
      return status;

   status = waveInPrepareHeader(m_hWaveIn,&m_wavehdr3,sizeof(WAVEHDR));   
   if(status!=MMSYSERR_NOERROR)
      return status;

   status = waveInPrepareHeader(m_hWaveIn,&m_wavehdr4,sizeof(WAVEHDR));   
   if(status!=MMSYSERR_NOERROR)
      return status;

   status=waveInAddBuffer(m_hWaveIn,&m_wavehdr1,sizeof(WAVEHDR));
   if(status!=MMSYSERR_NOERROR)
      return status;

   m_nfirst = 1;
   m_nCountSample = 0;
   m_nEndBuffer = 0;

   m_bReset=true;

   status=waveInStart(m_hWaveIn);

   return status;
}

/**** Stop record speech ****/
MMRESULT Sound::StopRecordSound(void){
   MMRESULT status = MMSYSERR_NOERROR;

   m_bReset=false;
   status = waveInReset(m_hWaveIn);

   if(status!=MMSYSERR_NOERROR)
      return status;

   waveInUnprepareHeader( m_hWaveIn, &m_wavehdr1, sizeof(WAVEHDR)); 
   waveInUnprepareHeader( m_hWaveIn, &m_wavehdr2, sizeof(WAVEHDR)); 
   waveInUnprepareHeader( m_hWaveIn, &m_wavehdr3, sizeof(WAVEHDR)); 
   waveInUnprepareHeader( m_hWaveIn, &m_wavehdr4, sizeof(WAVEHDR)); 

   if(status!=MMSYSERR_NOERROR)
      return status;

   status = waveInStop(m_hWaveIn);

   return status; 
}


short *Sound::GetDataBuffer(int *SizeBuffer){
    Ipp8u *tmp = NULL;

   if (m_nCountSample < m_nSizeBigBuffer){
      tmp=ippsMalloc_8u(m_nCountSample);
      ippsCopy_8u(m_pBufferOut,tmp,m_nCountSample);
   }else{
      m_nCountSample = m_nSizeBigBuffer;
      tmp=ippsMalloc_8u(m_nCountSample);
      ippsCopy_8u((m_pBufferOut + m_nEndBuffer), tmp, (m_nSizeBigBuffer - m_nEndBuffer));
      ippsCopy_8u(m_pBufferOut, tmp + (m_nSizeBigBuffer - m_nEndBuffer), m_nEndBuffer);
   }

   *SizeBuffer = m_nCountSample>>1;

    return (short*)tmp;
}