利用DirectSound实现声卡录音【老毕改版】【Part2】

来源：互联网发布：百度网络问诊编辑：程序博客网时间：2024/05/22 16:52

/*CSoundPlay.h*/
#pragma once 
#include "isound.h" 
class CSoundPlay :
    public ISound
{
public:
    CSoundPlay(void);
    ~CSoundPlay(void);
public:
    BOOL Play(void);
    BOOL Pause(void);
    BOOL Stop(void);
    void SetCurWnd(HWND hWnd);
protected:
    BOOL InitializeDevice(void);
    BOOL UninitializeDevice(void);
    BOOL CreateBuffer(void);
    void WriteData();
    BOOL CreateNotification();
private:
    static UINT ThreadProc(LPVOID); 
private:
    HWND m_hWnd;
    // Main Buffer 
    LPDIRECTSOUNDBUFFER m_lpBuffer;
    // Secondary Buffer 
    LPDIRECTSOUNDBUFFER8 m_lpBuffer8;
    LPDIRECTSOUNDNOTIFY8 m_lpNotify;
    // Device 
    LPDIRECTSOUND8 m_lpDevice;
    CWaveFile *m_pWaveFile;
    CWinThread* pThread;
    DSBPOSITIONNOTIFY m_NotifyPosition[NOTIFICATIONS_PORTION + 1];  
    BOOL m_bFinished;
public:
    float GetTimeLen(void);
    BOOL PlayBySystem(void);
};

/*CSoundPlay.cpp*/
#include "StdAfx.h" 
#include "SoundPlay.h" 
CSoundPlay::CSoundPlay(void):
m_bFinished(FALSE)
{
    m_dwBufferSize = m_dwNotifySize*NOTIFICATIONS_PORTION;
    m_pWaveFile = new CWaveFile;
}
CSoundPlay::~CSoundPlay(void)
{
    UninitializeDevice();
}
BOOL CSoundPlay::Play(void)
{
    HRESULT hr = m_pWaveFile->Open((LPTSTR)g_strfile.c_str(), &g_wformat, WAVEFILE_READ);
    if(FAILED(hr))
    {
        return FALSE;
    }
    try
    {
        CreateBuffer();
        CreateNotification();
        m_lpBuffer8->SetVolume(400);
        m_bFinished = FALSE;
        pThread = AfxBeginThread((AFX_THREADPROC)ThreadProc, this);
        return TRUE;
    }   
    catch (CException* e)
    {
        throw e;
    }
    return FALSE;
}
BOOL CSoundPlay::Pause(void)
{   
    return 0;
}
BOOL CSoundPlay::Stop(void)
{
    m_lpBuffer->Stop();
    if(pThread)
        pThread->Delete();
    m_pWaveFile->Close();
    return 0;
}
BOOL CSoundPlay::CreateBuffer(void)
{   
    DWORD dwSizeRead = m_dwBufferSize;
    DSBUFFERDESC dsBufDesc;
    ZeroMemory(&dsBufDesc, sizeof(DSBUFFERDESC));
    dsBufDesc.dwSize = sizeof(DSBUFFERDESC);
    dsBufDesc.dwFlags =DSBCAPS_CTRLPAN|DSBCAPS_CTRLVOLUME|DSBCAPS_CTRLPOSITIONNOTIFY|
        DSBCAPS_CTRLFREQUENCY|DSBCAPS_GLOBALFOCUS;
    dsBufDesc.dwBufferBytes = dwSizeRead;
    dsBufDesc.lpwfxFormat = m_pWaveFile->GetFormat();
    HRESULT hr = m_lpDevice->CreateSoundBuffer(&dsBufDesc, &m_lpBuffer, NULL);
    if(FAILED(hr))
    {
        return FALSE;
    }
    hr = m_lpBuffer->QueryInterface(IID_IDirectSoundBuffer8, (LPVOID*)&m_lpBuffer8);
    if(FAILED(hr))
    {
        return FALSE;
    }
    m_lpBuffer->Release();
    return TRUE;
}
BOOL CSoundPlay::InitializeDevice(void)
{
    HRESULT hr = DirectSoundCreate8(NULL, &m_lpDevice, NULL);
    if(FAILED(hr))
    {
        return FALSE;
    }   
    hr = m_lpDevice->SetCooperativeLevel(m_hWnd, DSSCL_PRIORITY);
    if(FAILED(hr))
    {
        return FALSE;
    }
    return TRUE;
}
BOOL CSoundPlay::UninitializeDevice(void)
{
    if(m_pWaveFile != NULL)
    {
        delete m_pWaveFile;
    }
    if(m_lpDevice != NULL)
        m_lpDevice->Release();
    return TRUE;
}
UINT CSoundPlay::ThreadProc(LPVOID lpParam)
{
    CSoundPlay* lpSoundPlay = (CSoundPlay*)lpParam;
    LPVOID lpLockbuf;
    DWORD dwLen;
    DWORD dwWrite;
    lpSoundPlay->m_lpBuffer8->Lock(0, 0, &lpLockbuf, &dwLen, NULL, NULL, DSBLOCK_ENTIREBUFFER);
    lpSoundPlay->m_pWaveFile->Read((BYTE*)lpLockbuf, dwLen, &dwWrite);
    lpSoundPlay->m_lpBuffer8->Unlock(lpLockbuf, dwLen, NULL, 0);
    lpSoundPlay->m_lpBuffer8->SetCurrentPosition(0);
    lpSoundPlay->m_lpBuffer8->Play(0, 0, DSBPLAY_LOOPING);
    DWORD dwResult;
    while (!lpSoundPlay->m_bFinished)
    {
        dwResult = MsgWaitForMultipleObjects(1, &lpSoundPlay->m_hEventNotify, FALSE, INFINITE, NULL);
        switch(dwResult)
        {
            case WAIT_OBJECT_0:
                lpSoundPlay->WriteData();
        }
    }
    lpSoundPlay->m_lpBuffer8->Stop();
    return 0;
}
BOOL CSoundPlay::CreateNotification()
{
    m_hEventNotify = CreateEvent(NULL, FALSE, FALSE, NULL);
    HRESULT hr = m_lpBuffer8->QueryInterface(IID_IDirectSoundNotify, (VOID**)&m_lpNotify);
    if(FAILED(hr))
    {
        return FALSE;
    }
    for (int i=0; i<NOTIFICATIONS_PORTION; i++)
    {
        m_NotifyPosition[i].dwOffset = (i + 1)*m_dwNotifySize - 1;
        m_NotifyPosition[i].hEventNotify = m_hEventNotify;
    }
    hr = m_lpNotify->SetNotificationPositions(NOTIFICATIONS_PORTION, m_NotifyPosition);
    if(FAILED(hr))
    {
        return FALSE;
    }
    return TRUE;
}
void CSoundPlay::WriteData()
{
    VOID *pbCaptureData = NULL;
    DWORD dwCaptureLength = 0;
    VOID *pbCaptureData2 = NULL;
    DWORD dwCaptureLength2 = 0;
    UINT dwDataWrote;   
    DWORD dwBytesWrittenToBuf;
    HRESULT hr = m_lpBuffer8->Lock(m_dwBufferOffset, m_dwNotifySize, 
        &pbCaptureData, &dwCaptureLength,
        &pbCaptureData2, &dwCaptureLength2, 
        0L);
    if(hr == DSERR_BUFFERLOST)
    {
        m_lpBuffer8->Restore();
        hr = m_lpBuffer8->Lock(m_dwBufferOffset, m_dwNotifySize, 
            &pbCaptureData, &dwCaptureLength,
            &pbCaptureData2, &dwCaptureLength2, 
            0L);
    }
    if(SUCCEEDED(hr))
    {
        hr = m_pWaveFile->Read((BYTE*)pbCaptureData, dwCaptureLength, &dwBytesWrittenToBuf);
        if(pbCaptureData2 != NULL)
        {
            hr = m_pWaveFile->Read((BYTE*)pbCaptureData2, dwCaptureLength2, &dwBytesWrittenToBuf);
        }
        m_dwBufferOffset += dwBytesWrittenToBuf;
        m_dwBufferOffset %= m_dwBufferSize;
        if(dwBytesWrittenToBuf < m_dwNotifySize)
        {
            FillMemory((BYTE*)pbCaptureData + dwBytesWrittenToBuf, 
                m_dwNotifySize-dwBytesWrittenToBuf, 
                (BYTE)(m_pWaveFile->m_pwfx->wBitsPerSample == 8 ? 128 : 0 ) );
            m_bFinished = TRUE;
        }
        m_lpBuffer8->Unlock(pbCaptureData, dwCaptureLength, 
            pbCaptureData2, dwCaptureLength2);  
    }
}
void CSoundPlay::SetCurWnd(HWND hWnd)
{
    m_hWnd = hWnd;
    InitializeDevice();
}
float CSoundPlay::GetTimeLen(void)
{
    DWORD dwSize = m_pWaveFile->GetSize();
    return dwSize/g_wformat.nSamplesPerSec;
}
BOOL CSoundPlay::PlayBySystem(void)
{
    HRESULT hr = PlaySound((LPCTSTR)g_strfile.c_str(), NULL, SND_ASYNC|SND_NODEFAULT);
    if (hr == S_OK)
    {
        return TRUE;
    }
    return FALSE;
}