D:/work/code_by/Wave/waveAPI.cpp

查看本檔案說明文件.

#include "waveAPI.h"
int           samplingRate = 44100,
              channels = 1;
HWND          targetWindow;

WAVEFORMATEX  format;

HWAVEOUT      waveOutHandle;
WAVEHDR       waveOutHeader;
bool          waveOutWriteStart;
int           waveOutDoneCount; // how many wibl items has been returned from waveOut
WAVEHDR       waveOutHeaders[WIBLSIZE];

HWAVEIN       waveInHandle;
WAVEHDR       waveInHeaders[WIBLSIZE];
short int **  waveInBuffers;
int           wiblCount, // how many wibl items has been added
              wiblIndex; // how many wibl items has been returned
int           waveInStatus; // 1: for recording, 0: else

//---
bool waveAPIInitialized = false;
//---
//---------------------------------------------------------------------------
void waveAPIInit()
{
  if (waveAPIInitialized)
    return;

  waveInBuffers = new short int *[WIBLSIZE];
  for(int i = 0; i < WIBLSIZE; i++)
    waveInBuffers[i] = new short int[FRAMESIZE];
  waveAPIInitialized = true;

  waveOutHandle = NULL;
  waveInHandle = NULL;
}

//---------------------------------------------------------------------------
bool OpenWaveIn()
{
  if (!waveAPIInitialized)
    waveAPIInit();

  format.wFormatTag = WAVE_FORMAT_PCM; // defined in mmreg.h
  format.nChannels = channels;
  format.nSamplesPerSec = samplingRate;
  format.wBitsPerSample = 16;
  format.nBlockAlign = format.wBitsPerSample * format.nChannels / 8; // only for WAVE_FORMAT_PCM
  format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
  format.cbSize = 0;

  if (AssertWaveError(
        WAVE_IN,
        waveInOpen( &waveInHandle, WAVE_MAPPER, &format, (DWORD)waveInProc, NULL, CALLBACK_FUNCTION)
      ) != MMSYSERR_NOERROR)
    return false;

  waveInStatus = 0;
  return true;
}

//---------------------------------------------------------------------------
void StartWaveIn()
{
  waveInStatus = 1;
  AssertWaveError( WAVE_IN, waveInStart( waveInHandle ));

  WAVEHDR * _h;
  for( int i = 0; i < WIBLSIZE; i++)
  {
    memset( waveInBuffers[i], 0, FRAMESIZE * 2 );

    _h = &(waveInHeaders[i]);
    _h->lpData = (char *)(waveInBuffers[i]);
    _h->dwBufferLength = FRAMESIZE * 2;
    _h->dwBytesRecorded = 0;
    _h->dwUser = 0;
    _h->dwFlags = 0;
    _h->dwLoops = 1;
    _h->lpNext = NULL;
    _h->reserved = 0;
    AssertWaveError(WAVE_IN, waveInPrepareHeader( waveInHandle, _h, sizeof(WAVEHDR) ));
  }

  AssertWaveError(WAVE_IN, waveInAddBuffer( waveInHandle, &(waveInHeaders[0]), sizeof(WAVEHDR) ));
  AssertWaveError(WAVE_IN, waveInAddBuffer( waveInHandle, &(waveInHeaders[1]), sizeof(WAVEHDR) ));
  wiblCount = 2;
}

//---------------------------------------------------------------------------
void OpenWaveOut()
{
  if (!waveAPIInitialized)
    waveAPIInit();

  format.wFormatTag = WAVE_FORMAT_PCM; // defined in mmreg.h
  format.nChannels = channels;
  format.nSamplesPerSec = samplingRate;
  format.wBitsPerSample = 16;
  format.nBlockAlign = format.wBitsPerSample * format.nChannels / 8; // only for WAVE_FORMAT_PCM
  format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
  format.cbSize = 0;

  AssertWaveError(
    WAVE_OUT,
    waveOutOpen( &waveOutHandle, WAVE_MAPPER, &format, (DWORD)waveOutProc, NULL, CALLBACK_FUNCTION));

  WAVEHDR * _h;
  for( int i = 0; i < WIBLSIZE; i++)
  {
    _h = &(waveOutHeaders[i]);
    _h->dwBytesRecorded = 0;
    _h->dwUser = 0;
    _h->dwFlags = 0;
    _h->dwLoops = 1;
    _h->lpNext = NULL;
    _h->reserved = 0;
    _h->lpData = (char *)(waveInBuffers[i]);;
    _h->dwBufferLength = FRAMESIZE * 2;
    AssertWaveError( WAVE_OUT, waveOutPrepareHeader( waveOutHandle, _h, sizeof(WAVEHDR) ));
  }

  waveOutWriteStart = false;
  waveOutDoneCount = 0;
}

//---------------------------------------------------------------------------
void CloseWaveOut()
{
  AssertWaveError( WAVE_OUT, waveOutReset( waveOutHandle ));

  WAVEHDR * _h;
  for( int i = 0; i < WIBLSIZE; i++)
  {
    _h = &(waveOutHeaders[i]);
    AssertWaveError( WAVE_OUT, waveOutUnprepareHeader( waveOutHandle, _h, sizeof(WAVEHDR) ));
  }

  AssertWaveError( WAVE_OUT, waveOutClose( waveOutHandle ));
}

//---------------------------------------------------------------------------
void CloseWaveIn()
{
  // exception handling mechanism not implemented yet
  // opened and active mechanism not implemented yet
  waveInStatus = 0;
  AssertWaveError( WAVE_IN, waveInReset( waveInHandle ));

  WAVEHDR * _h;
  for( int i = 0; i < WIBLSIZE; i++)
  {
    _h = &(waveInHeaders[i]);
    AssertWaveError(WAVE_IN, waveInUnprepareHeader( waveInHandle, _h, sizeof(WAVEHDR) ));
  }

  AssertWaveError( WAVE_IN, waveInClose( waveInHandle ));
  wiblIndex = 0;
}

//---------------------------------------------------------------------------
void CALLBACK waveOutProc(
    HWAVEOUT hwi,
    UINT uMsg,
    DWORD dwInstance,
    DWORD dwParam1,
    DWORD dwParam2)
{
  switch (uMsg)
  {
    case WOM_CLOSE:
      break;
    case WOM_DONE:
      PostMessage( targetWindow, MSG_BUFFER_DONE, dwParam1, dwParam2 );
      waveOutDoneCount++;
      break;
  }
}

//---------------------------------------------------------------------------
void CALLBACK waveInProc(
    HWAVEIN hwi,
    UINT uMsg,
    DWORD dwInstance,
    DWORD dwParam1,
    DWORD dwParam2)
{
  switch (uMsg)
  {
    case WIM_DATA :
    {
      ++wiblIndex;
      WAVEHDR * _h;

      if (waveInStatus == 0)
        return;

      //add one waveIn buffer
      _h = &(waveInHeaders[wiblCount % WIBLSIZE]);
      AssertWaveError( 0, waveInAddBuffer( waveInHandle, _h, sizeof(WAVEHDR) ));
      PostMessage( targetWindow, MSG_BUFFER_IN, 0, 0 );
      ++wiblCount;

      // accumulate at least two buffers to start waveOutWrite
      if (!waveOutWriteStart)
        if (wiblIndex == 2)
        {
          waveOutWriteStart = true;
          _h = &(waveOutHeaders[0]);
          WaveProcessor(_h, waveInBuffers[0], FRAMESIZE);
          if (waveOutHandle)
            AssertWaveError( 1, waveOutWrite( waveOutHandle, _h, sizeof(WAVEHDR) ));
          WavePostProcessor(_h, waveInBuffers[0], FRAMESIZE);
        }
        else
          return;

      int _i = (wiblIndex - 1) % WIBLSIZE;
      _h = &(waveOutHeaders[_i]);
      WaveProcessor(_h, waveInBuffers[_i], FRAMESIZE);
      if (waveOutHandle)
        AssertWaveError( 2, waveOutWrite( waveOutHandle, _h, sizeof(WAVEHDR) ));
      WavePostProcessor(_h, waveInBuffers[_i], FRAMESIZE);
      break;
    }
    case WIM_OPEN :
      break;
    case WIM_CLOSE :
      break;
  }
}

---