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

查看本檔案說明文件.

#include <stdio.h>
#include "WavePlayer.h"

TWavePlayerWindow::TWavePlayerWindow(TWavePlayer *Wave) : THiddenWindow("WavePlayerWindow")
{
  WavePlayer = Wave;
}

void TWavePlayerWindow::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  if (uMsg == WM_APP + 111)
    WavePlayer->RecordComplete();
  else if (uMsg == WM_APP + 222)
    WavePlayer->PlayComplete();
}

static void CALLBACK WavePlayerInProc(HWAVEIN hwi, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
  TWavePlayer *WavePlayer;

  if (uMsg == WIM_DATA)  //代表錄滿一個buffer
  {
    WavePlayer = (TWavePlayer *)dwInstance;
    if (WavePlayer->GetMode() != TWavePlayer::IDLE)
      WavePlayer->RecordABuffer();
  }
}

static void CALLBACK WavePlayerOutProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
  TWavePlayer *WavePlayer;

  if (uMsg == WOM_DONE)  //代表播完一個buffer
  {
    WavePlayer = (TWavePlayer *)dwInstance;
    if (WavePlayer->GetMode() != TWavePlayer::IDLE)
      WavePlayer->PlayABuffer();
  }
}

TWavePlayer::TWavePlayer(int sampleRate, int bitRate) : Speaker()
{
  int i;

  mode = IDLE;  //非錄音、非播放模式
  echoOn = false;  //沒有迴音
  echoVolume = 5;  //迴音音量
  wave = NULL;
  Clear();  //清除聲波

  for (i = 0; i < 3; i++)
  {
    waveInHdr[i].lpData = NULL;
    waveOutHdr[i].lpData = NULL;
  }

  SetFormat(sampleRate, bitRate);
  SetBufferSize(sampleRate / 5);
  HiddenWindow = new TWavePlayerWindow(this);  //建立一隱藏視窗
}

TWavePlayer::~TWavePlayer()
{
  StopRecord();  //停止錄音
  StopPlay();  //停止播放
  Clear();  //清除聲波
  delete HiddenWindow;  //釋放隱藏視窗
}

int TWavePlayer::GetMode(void)
{
  return mode;  //錄音或播放模式
}

int TWavePlayer::GetSampleRate(void)
{
  return waveFormat.nSamplesPerSec;  //每秒幾個sample
}

int TWavePlayer::GetBitRate(void)
{
  return waveFormat.wBitsPerSample;  //每個sample幾bit
}

bool TWavePlayer::IsEchoOn(void)
{
  return echoOn;  //是否已開啟錄音模式
}

void TWavePlayer::SetFormat(int newSampleRate, int newBitRate)
{
  int i;

  if (mode != IDLE)  //正在錄音或播放
    return;

  if (newBitRate != GetBitRate())
  {
    if (newBitRate == 8)
      for (i = 0; i < waveSize; i++)
        wave[i] = wave[i] >> 8;
    else
      for (i = 0; i < waveSize; i++)
        wave[i] = wave[i] << 8;
  }
  Resample(newSampleRate);

  waveFormat.wFormatTag = WAVE_FORMAT_PCM;
  waveFormat.nChannels = 1;
  waveFormat.nSamplesPerSec = newSampleRate;
  waveFormat.wBitsPerSample = newBitRate;
  waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
  waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
  waveFormat.cbSize = 0;

  bytesPerSample = newBitRate / 8;  //1代表8 bits，2代表16 bits
  bytesPerBuffer = bufferSize * bytesPerSample;
}

void TWavePlayer::Resample(int newSampleRate)
{
  int i, j, r, n, sampleRate;
  int *newWave;

  sampleRate = GetSampleRate();
  if (newSampleRate == sampleRate || waveSize == 0)
    return;

  //本來是 waveSize = (waveSize - 1) * newSampleRate / sampleRate，
  //但是 (waveSize - 1) * newSampleRate 可能會overflow，所以拆成兩行
  r = (waveSize - 1) % sampleRate;
  waveSize = (waveSize - 1 - r) / sampleRate * newSampleRate + r * newSampleRate / sampleRate;
  bufferTotal = (waveSize + bufferSize - 1) / bufferSize;
  newWave = new int[bufferTotal * bufferSize + 16000];
  for (i = 0; i < waveSize; i++)
  {
    //本來是 j = i * sampleRate / newSampleRate
    //但是 i * sampleRate 可能會overflow，所以拆成兩行
    r = i % newSampleRate;
    j = (i - r) / newSampleRate * sampleRate + r * sampleRate / newSampleRate;
    n = (10.0f * i * sampleRate) / newSampleRate - 10 * j;
    newWave[i] = (wave[j] * (10 - n) + wave[j + 1] * n) / 10;
  }
  memset(newWave + waveSize, 0, (bufferTotal * bufferSize + 16000 - waveSize) * sizeof(int));  //把多餘的部份設為靜音

  delete[] wave;
  wave = newWave;
}

int TWavePlayer::GetBufferSize(void)
{
  return bufferSize;
}

void TWavePlayer::SetBufferSize(int size)
{
  if (mode != IDLE)  //正在錄音或播放
    return;

  bufferSize = size;
  bytesPerBuffer = bufferSize * bytesPerSample;
  bufferTotal = (waveSize + bufferSize - 1) / bufferSize;
}

void TWavePlayer::SetWave(int *w, int size)
{
  if (mode != IDLE)  //正在錄音或播放
    return;

  Clear();  //清除聲波
  waveSize = size;
  duration = (float)waveSize / GetSampleRate();
  bufferTotal = (waveSize + bufferSize - 1) / bufferSize;  //buffer個數
  wave = new int[bufferTotal * bufferSize + 16000];  //讓wave陣列大一點，比較不用判斷陣列的邊界問題
  memcpy(wave, w, waveSize * sizeof(int));  //把聲波複製到wave陣列
  memset(wave + waveSize, 0, (bufferTotal * bufferSize + 16000 - waveSize) * sizeof(int));  //把多餘的部份設為靜音
}

void TWavePlayer::SetWave(TWaveFile *WaveFile)
{
  if (mode != IDLE)  //正在錄音或播放
    return;

  Clear();  //清除聲波
  SetFormat(WaveFile->GetSampleRate(), WaveFile->GetBitRate());  //把格式設成和WaveFile相同
  SetWave(WaveFile->wave, WaveFile->waveSize);  //把聲波設成和WaveFile相同
}

bool TWavePlayer::Load(char *name)
{
  TWaveFile WaveFile;

  if (mode != IDLE)  //正在錄音或播放
    return false;

  Clear();  //清除聲波
  if (!WaveFile.Load(name))  //載入wav檔
    return false;
  SetWave(&WaveFile);  //把載入的聲波複製進來
  return true;
}

bool TWavePlayer::Save(char *name)
{
  TWaveFile WaveFile;

  if (mode != IDLE)  //正在錄音或播放
    return false;

  WaveFile.SetFormat(GetSampleRate(), GetBitRate());  //設定WaveFile的格式
  WaveFile.SetWave(wave, waveSize);  //設定WaveFile的聲波
  return WaveFile.Save(name);  //儲存wav檔
}

bool TWavePlayer::OpenRecordDevice(void)
{
  int i;

  if (mode == RECORDING)  //正在錄音
    return true;

  if (waveInOpen(&waveIn, WAVE_MAPPER, &waveFormat, (DWORD)WavePlayerInProc, (DWORD)this, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)  //錄音設備開啟失敗
    return false;

  for (i = 0; i < 3; i++)
  {
    waveInHdr[i].dwBufferLength = bytesPerBuffer;
    waveInHdr[i].lpData = new char[bytesPerBuffer];
    waveInHdr[i].dwFlags = 0;
    memset(waveInHdr[i].lpData, bytesPerSample == 1? 128 : 0, bytesPerBuffer);  //先清成靜音
    waveInPrepareHeader(waveIn, waveInHdr + i, sizeof(WAVEHDR));
  }
  //一次錄2個buffer才不會有間斷的聲音
  waveInAddBuffer(waveIn, waveInHdr, sizeof(WAVEHDR));
  waveInAddBuffer(waveIn, waveInHdr + 1, sizeof(WAVEHDR));
  return true;
}

void TWavePlayer::CloseRecordDevice(void)
{
  int i;

  waveInReset(waveIn);
  for (i = 0; i < 3; i++)
  {
    waveInUnprepareHeader(waveIn, waveInHdr + i, sizeof(WAVEHDR));
    delete[] waveInHdr[i].lpData;
    waveInHdr[i].lpData = NULL;
  }
  waveInClose(waveIn);
}

bool TWavePlayer::OpenPlayDevice(void)
{
  int i;

  if (mode == PLAYING)  //正在播放
    return true;

  if (waveOutOpen(&waveOut, WAVE_MAPPER, &waveFormat, (DWORD)WavePlayerOutProc, (DWORD)this, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)  //放音設備開啟失敗
    return false;

  for (i = 0; i < 3; i++)
  {
    waveOutHdr[i].dwBufferLength = bytesPerBuffer;
    waveOutHdr[i].lpData = new char[bytesPerBuffer];
    waveOutHdr[i].dwFlags = waveOutHdr[i].dwLoops = 0;
    waveOutPrepareHeader(waveOut, waveOutHdr + i, sizeof(WAVEHDR));
  }
  return true;
}

void TWavePlayer::ClosePlayDevice(void)
{
  int i;

  waveOutReset(waveOut);
  for (i = 0; i < 3; i++)
  {
    waveOutUnprepareHeader(waveOut, waveOutHdr + i, sizeof(WAVEHDR));
    delete[] waveOutHdr[i].lpData;
    waveOutHdr[i].lpData = NULL;
  }
  waveOutClose(waveOut);
}

bool TWavePlayer::Record(int maxDuration)
{
  if (mode == RECORDING)  //正在錄音
    return true;

  StopPlay();  //停止播放
  Clear();  //清除舊的聲波
  if (!OpenRecordDevice())  //開啟錄音裝置
    return false;

  mode = RECORDING;
  duration = maxDuration;  //最多要錄幾秒
  bufferTotal = (duration * GetSampleRate() + bufferSize - 1) / bufferSize;  //最多會用到幾個buffer
  wave = new int[bufferTotal * bufferSize + 16000];  //讓wave陣列大一點，比較不用判斷陣列的邊界問題
  waveInStart(waveIn);  //開始錄音

  if (duration == 0)
  {
    RecordComplete();
    return true;
  }

  if (echoOn)  //已經開啟迴音模式
  {
    if (OpenPlayDevice())  //開啟播放裝置
      firstEcho = true;
  }

  return true;
}

void TWavePlayer::StopRecord(void)
{
  if (mode != RECORDING)  //不是錄音模式
    return;

  mode = IDLE;
  bufferTotal = (waveSize + bufferSize - 1) / bufferSize;  //總共錄了幾個buffer
  duration = (float)waveSize / GetSampleRate();  //總共錄了幾秒
  CloseRecordDevice();  //關閉錄音裝置
  if (echoOn)
    ClosePlayDevice();  //關閉放音裝置
}

bool TWavePlayer::Play(void)
{
  int i;

  if (mode == PLAYING)  //正在播放
    return true;

  StopRecord();  //停止錄音
  if (!OpenPlayDevice())  //開啟播放裝置
    return false;

  mode = PLAYING;
  playBufferCount = 0;  //已播放的buffer數目

  if (waveSize == 0)
  {
    PlayComplete();
    return true;
  }

  WaveCopy(waveOutHdr[0].lpData, wave, bufferSize);
  if (waveSize > bufferSize)
    WaveCopy(waveOutHdr[1].lpData, wave + bufferSize, bufferSize);

  waveOutWrite(waveOut, waveOutHdr, sizeof(WAVEHDR));  //播放
  if (waveSize > bufferSize)
    waveOutWrite(waveOut, waveOutHdr + 1, sizeof(WAVEHDR));  //播放

  return true;
}

void TWavePlayer::StopPlay(void)
{
  if (mode != PLAYING)  //不是播放模式
    return;

  mode = IDLE;
  ClosePlayDevice();  //關閉播放裝置
}

void TWavePlayer::EchoOn(void)
{
  if (echoOn)  //已經開啟迴音模式
    return;

  echoOn = true;
  if (mode == RECORDING)  //錄音模式
    if (OpenPlayDevice())  //開啟播放裝置
      firstEcho = true;
}

void TWavePlayer::EchoOff(void)
{
  if (!echoOn)  //沒有開啟迴音模式
    return;

  echoOn = false;
  if (mode == RECORDING)  //錄音模式
    ClosePlayDevice();  //關閉放音裝置
}

float TWavePlayer::GetDuration(void)
{
  return duration;  //聲波秒數
}

float TWavePlayer::GetTimeCode(void)
{
  if (mode == IDLE || bufferTotal == 0)  //沒有在錄音或播放
    return 0;
  return (mode == RECORDING? recordBufferCount : playBufferCount) * duration / bufferTotal;  //已錄或播放的秒數
}

void TWavePlayer::Seek(int percent)
{
  if (mode != PLAYING)  //沒有在播放
    return;

  playBufferCount = bufferTotal * percent / 100;  //把播放的起點移到正確的進度
}

void TWavePlayer::Clear()
{
  delete[] wave;
  wave = NULL;
  waveSize = 0;
  duration = 0.0f;
  bufferTotal = recordBufferCount = playBufferCount = 0;
}

void TWavePlayer::Trim(int from, int to)
{
  int *newwave;

  if (from < 0)
    from = 0;
  if (to >= waveSize)
    to = waveSize - 1;
  if (from > to)
    to = from - 1;
  waveSize = to - from + 1;
  duration = (float)waveSize / GetSampleRate();
  bufferTotal = (waveSize + bufferSize - 1) / bufferSize;  //buffer個數
  newwave = new int[bufferTotal * bufferSize + 16000];  //讓wave陣列大一點，比較不用判斷陣列的邊界問題
  memcpy(newwave, wave + from, waveSize * sizeof(int));
  memset(newwave + waveSize, 0, (bufferTotal * bufferSize + 16000 - waveSize) * sizeof(int));  //把多餘的部份設為靜音
  delete[] wave;
  wave = newwave;
}

void TWavePlayer::RecordABuffer(void)
{
  if (mode != RECORDING)  //不是錄音模式
    return;

  WaveCopy(wave + waveSize, waveInHdr[recordBufferCount % 3].lpData, bufferSize);  //把這次錄好的聲波複製到wave陣列
  waveSize += bufferSize;  //wave陣列的大小變大

  ++recordBufferCount;  //已經錄完的buffer數目
  if (recordBufferCount == bufferTotal)  //錄音完畢
  {
    PostMessage(HiddenWindow->Handle, WM_APP + 111, 0, 0);
    return;
  }
  if (mode == RECORDING)
    Deliver(EVENT_RECORD_BUFFER, wave + (recordBufferCount - 1) * bufferSize);

  if (recordBufferCount < bufferTotal - 1)  //在錄音完畢之前
  {
    if (echoOn && firstEcho)  //正打開迴音
    {
      firstEcho = false;
      firstEchoBufferIndex = recordBufferCount - 1;  //第1個要迴音的buffer
      memset(waveOutHdr[0].lpData, bytesPerSample == 1? 128 : 0, bytesPerBuffer);  //清成靜音
      memcpy(waveOutHdr[1].lpData, waveInHdr[(recordBufferCount + 2) % 3].lpData, bytesPerBuffer);
      //一次播放2個buffer才不會有間斷的聲音
      waveOutWrite(waveOut, waveOutHdr, sizeof(WAVEHDR));
      waveOutWrite(waveOut, waveOutHdr + 1, sizeof(WAVEHDR));
    }

    waveInAddBuffer(waveIn, waveInHdr + (recordBufferCount + 1) % 3, sizeof(WAVEHDR));  //繼續錄音
  }
}

void TWavePlayer::PlayABuffer(void)
{
  WAVEHDR *waveHdr;
  int i, *ip3, vol;
  short *sp1, *sp2, *sp3;
  unsigned char *ucp1, *ucp2, *ucp3;

  ++playBufferCount;  //已經播完的buffer數目
  if (playBufferCount == bufferTotal && mode == PLAYING)  //播放完畢
  {
    PostMessage(HiddenWindow->Handle, WM_APP + 222, 0, 0);
    return;
  }
  if (mode == PLAYING)
    Deliver(EVENT_PLAY_BUFFER, wave + (playBufferCount - 1) * bufferSize);

  if (playBufferCount == bufferTotal - 1)  //即將播放完畢，只等最後一個buffer播放完畢
    return;

  waveHdr = waveOutHdr + (playBufferCount + 1) % 3;  //下次要播放的buffer
  if (echoOn)  //開啟迴音模式
  {
    if (bytesPerSample == 1)
    {
      ucp1 = (unsigned char *)waveHdr->lpData;  //下次要播放的buffer
      ucp2 = (unsigned char *)waveOutHdr[playBufferCount % 3].lpData;  //正在播放的buffer
      if (mode == RECORDING)  //錄音模式
      {
        ucp3 = (unsigned char *)waveInHdr[(firstEchoBufferIndex + playBufferCount) % 3].lpData;  //這次錄完的buffer，也就是這次要播的
        for (i = bufferSize - 1; i >= 0; i--)
        {
          vol = (ucp2[i] - 128) * echoVolume / 10 + ucp3[i];  //把正在播放和這次要播的混合在一起
          if (vol > 255)
            ucp1[i] = 255;
          else if (vol < 0)
            ucp1[i] = 0;
          else
            ucp1[i] = vol;
        }
      }
      else  //播放模式
      {
        ip3 = wave + (playBufferCount + 1) * bufferSize;  //這次要播的buffer
        for (i = bufferSize - 1; i >= 0; i--)
        {
          vol = (ucp2[i] - 128) * echoVolume / 10 + ip3[i] + 128;  //把這次播完和這次要播的混合在一起
          if (vol > 255)
            ucp1[i] = 255;
          else if (vol < 0)
            ucp1[i] = 0;
          else
            ucp1[i] = vol;
        }
      }
    }
    else
    {
      sp1 = (short *)waveHdr->lpData;  //下次要播放的buffer
      sp2 = (short *)waveOutHdr[playBufferCount % 3].lpData;  //正在播放的buffer
      if (mode == RECORDING)  //錄音模式
      {
        sp3 = (short *)waveInHdr[(firstEchoBufferIndex + playBufferCount) % 3].lpData;  //這次錄完的buffer，也就是這次要播的
        for (i = bufferSize - 1; i >= 0; i--)
        {
          vol = sp2[i] * echoVolume / 10 + sp3[i];  //把正在播放和這次要播的混合在一起
          if (vol > 32767)
            sp1[i] = 32767;
          else if (vol < -32768)
            sp1[i] = -32768;
          else
            sp1[i] = vol;
        }
      }
      else  //播放模式
      {
        ip3 = wave + playBufferCount * bufferSize;  //這次要播的buffer
        for (i = bufferSize - 1; i >= 0; i--)
        {
          vol = sp2[i] * echoVolume / 10 + ip3[i];  //把這次播完和這次要播的混合在一起
          if (vol > 32767)
            sp1[i] = 32767;
          else if (vol < -32768)
            sp1[i] = -32768;
          else
            sp1[i] = vol;
        }
      }
    }
    waveOutWrite(waveOut, waveHdr, sizeof(WAVEHDR));  //播放
  }
  else if (mode == PLAYING)  //沒有開啟迴音，播放模式
  {
    WaveCopy(waveHdr->lpData, wave + (playBufferCount + 1) * bufferSize, bufferSize);
    waveOutWrite(waveOut, waveHdr, sizeof(WAVEHDR));  //播放
  }
}

void TWavePlayer::RecordComplete(void)
{
  StopRecord();
  Deliver(EVENT_RECORD_COMPLETE);  //送出錄音完畢的訊息
}

void TWavePlayer::PlayComplete(void)
{
  StopPlay();
  Deliver(EVENT_PLAY_COMPLETE);  //送出播放完畢的訊息
}

---