HRESULT CreateCaptureBuffer(LPDIRECTSOUNDCAPTURE8 pDSC,
LPDIRECTSOUNDCAPTUREBUFFER8* ppDSCB8)
{
HRESULT hr;
DSCBUFFERDESC dscbd;
LPDIRECTSOUNDCAPTUREBUFFER pDSCB;
WAVEFORMATEX wfx =
{WAVE_FORMAT_PCM, 1, 11025, 11025*2, 4, 16, 0 };
// wFormatTag, nChannels, nSamplesPerSec, mAvgBytesPerSec,
// nBlockAlign, wBitsPerSample, cbSize
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 1;
wfx.nSamplesPerSec = 11025;
wfx.wBitsPerSample = 16;
wfx.nBlockAlign = wfx.nChannels * wfx.wBitsPerSample / 8;
wfx.cbSize = 0;
if ((NULL == pDSC) || (NULL == ppDSCB8))
return E_INVALIDARG;
dscbd.dwSize = sizeof(DSCBUFFERDESC);
dscbd.dwFlags = 0;
dscbd.dwBufferBytes = SAMPLES_BUFFER_SIZE * sizeof(short);
dscbd.dwReserved = 0;
dscbd.lpwfxFormat = &wfx;
dscbd.dwFXCount = 0;
dscbd.lpDSCFXDesc = NULL;
hr = pDSC->CreateCaptureBuffer(&dscbd, &pDSCB, NULL);
if (SUCCEEDED(hr))
{
hr = pDSCB->QueryInterface(IID_IDirectSoundCaptureBuffer8, (LPVOID*)ppDSCB8);
pDSCB->Release();
}
else
{
fprintf(stderr, "%4.4u %s : 0x%8.8x\n", __LINE__, __FILE__, hr);
}
return hr;
}
bool nuiAudioDevice_DirectSound::Open(std::vector<uint32>& rInputChannels, std::vector<uint32>& rOutputChannels, double SampleRate, uint32 BufferSize, nuiAudioProcessFn pProcessFunction)
{
if (!mpDirectSound)
return false;
HRESULT hr = S_OK;
mAudioProcessFn = pProcessFunction;
mBufferSize = BufferSize;
hr = mpDirectSound->SetCooperativeLevel(GetDesktopWindow(), DSSCL_EXCLUSIVE);
mHasInput = (rInputChannels.size() > 0) && (mInputChannels.size() > 0);
mHasOutput = (rOutputChannels.size() > 0) && (mOutputChannels.size() > 0);
mpInputBuffer = NULL;
mpOutputBuffer = NULL;
if (!mHasInput && !mHasOutput)
return false;
// init ringbuffer
mpRingBuffer = new nglRingBuffer(BufferSize*4, sizeof(float), rOutputChannels.size());
mpRingBuffer->AdvanceWriteIndex(BufferSize);
// init input buffers
if (mHasInput)
{
{
mActiveInputChannels = rInputChannels;
}
WAVEFORMATEX IFormat;
IFormat.wFormatTag = WAVE_FORMAT_PCM;
IFormat.nChannels = (WORD)mInputChannels.size();
IFormat.nSamplesPerSec = ToNearest(SampleRate);
IFormat.wBitsPerSample = 16;
IFormat.nAvgBytesPerSec = IFormat.nChannels * IFormat.nSamplesPerSec * (IFormat.wBitsPerSample / 8);
IFormat.nBlockAlign = IFormat.nChannels * (IFormat.wBitsPerSample / 8);
IFormat.cbSize = 0;
DSCBUFFERDESC IBufferDesc;
memset(&IBufferDesc, 0, sizeof(IBufferDesc));
IBufferDesc.dwSize = sizeof(DSCBUFFERDESC);
IBufferDesc.dwFlags = DSCBCAPS_WAVEMAPPED;
IBufferDesc.dwBufferBytes = (IFormat.wBitsPerSample / 8) * IFormat.nChannels * BufferSize * 2;
IBufferDesc.dwReserved = 0;
IBufferDesc.lpwfxFormat = &IFormat;
IBufferDesc.dwFXCount = 0;
IBufferDesc.lpDSCFXDesc = NULL;
NGL_ASSERT(mpDirectSoundCapture);
hr = mpDirectSoundCapture->CreateCaptureBuffer(&IBufferDesc, &mpInputBuffer, NULL);
}
// init output buffers
if (mHasOutput)
{
{
mActiveOutputChannels = rOutputChannels;
}
WAVEFORMATEX OFormat;
OFormat.wFormatTag = WAVE_FORMAT_PCM;
OFormat.nChannels = (WORD)mOutputChannels.size();
OFormat.nSamplesPerSec = ToNearest(SampleRate);
OFormat.wBitsPerSample = 16;
OFormat.nAvgBytesPerSec = OFormat.nChannels * OFormat.nSamplesPerSec * (OFormat.wBitsPerSample / 8);
OFormat.nBlockAlign = OFormat.nChannels * OFormat.wBitsPerSample / 8;
OFormat.cbSize = 0;
DSBUFFERDESC OBufferDesc;
memset(&OBufferDesc, 0, sizeof(OBufferDesc));
OBufferDesc.dwSize = sizeof(OBufferDesc);
OBufferDesc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_CTRLPOSITIONNOTIFY;
OBufferDesc.dwBufferBytes = (OFormat.wBitsPerSample / 8) * OFormat.nChannels * BufferSize * 2;
OBufferDesc.dwReserved = 0;
OBufferDesc.lpwfxFormat = &OFormat;
hr = mpDirectSound->CreateSoundBuffer(&OBufferDesc, &mpOutputBuffer, NULL);
}
// create event for notifications
mNotifInputEvent[0] = CreateEvent(NULL, FALSE, FALSE, _T("NUI_DSoundInputEvent0"));
mNotifInputEvent[1] = CreateEvent(NULL, FALSE, FALSE, _T("NUI_DSoundInputEvent1"));
mNotifOutputEvent[0] = CreateEvent(NULL, FALSE, FALSE, _T("NUI_DSoundOutputEvent0"));
mNotifOutputEvent[1] = CreateEvent(NULL, FALSE, FALSE, _T("NUI_DSoundOutputEvent1"));
// set the notification for the input buffer
if (mHasInput)
{
// Setup the notification positions
ZeroMemory( &mInputPosNotify, sizeof(DSBPOSITIONNOTIFY) * 2);
mInputPosNotify[0].dwOffset = BufferSize * sizeof(int16) * mInputChannels.size() - 1;
mInputPosNotify[0].hEventNotify = mNotifInputEvent[0];
mInputPosNotify[1].dwOffset = BufferSize * sizeof(int16) * mInputChannels.size() * 2 - 1;
mInputPosNotify[1].hEventNotify = mNotifInputEvent[1];
LPDIRECTSOUNDNOTIFY pInputNotify = NULL;
if( FAILED( hr = mpInputBuffer->QueryInterface( IID_IDirectSoundNotify, (VOID**)&pInputNotify ) ) )
{
NGL_LOG(_T("nuiAudioDevice_DirectSound"), NGL_LOG_ERROR, _T("Open ERROR : failed in querying interface for input notifications.\n"));
return false;
}
// Tell DirectSound when to notify us. the notification will come in the from
// of signaled events that are handled in WinMain()
if( FAILED( hr = pInputNotify->SetNotificationPositions( 2, mInputPosNotify ) ) )
{
NGL_LOG(_T("nuiAudioDevice_DirectSound"), NGL_LOG_ERROR, _T("Open ERROR : failed in setting notifications for input\n"));
return false;
}
pInputNotify->Release();
}
// set the notification events for the output buffer
if (mHasOutput)
{
// Setup the notification positions
ZeroMemory( &mOutputPosNotify, sizeof(DSBPOSITIONNOTIFY) * 2);
mOutputPosNotify[0].dwOffset = BufferSize * sizeof(int16) * mOutputChannels.size() - 1;
mOutputPosNotify[0].hEventNotify = mNotifOutputEvent[0];
mOutputPosNotify[1].dwOffset = BufferSize * sizeof(int16) * mOutputChannels.size() * 2 - 1;
mOutputPosNotify[1].hEventNotify = mNotifOutputEvent[1];
LPDIRECTSOUNDNOTIFY pOutputNotify = NULL;
if( FAILED( hr = mpOutputBuffer->QueryInterface( IID_IDirectSoundNotify, (VOID**)&pOutputNotify ) ) )
{
NGL_LOG(_T("nuiAudioDevice_DirectSound"), NGL_LOG_ERROR, _T("Open ERROR : failed in querying interface for output notifications.\n"));
return false;
}
// Tell DirectSound when to notify us. the notification will come in the from
// of signaled events that are handled in WinMain()
if( FAILED( hr = pOutputNotify->SetNotificationPositions( 2, mOutputPosNotify ) ) )
{
NGL_LOG(_T("nuiAudioDevice_DirectSound"), NGL_LOG_ERROR, _T("Open ERROR : failed in setting notifications for output\n"));
return false;
}
pOutputNotify->Release();
}
// start input processing thread
mpProcessingTh = new nuiAudioDevice_DS_ProcessingTh(this, mNotifInputEvent[0], mNotifInputEvent[1], mAudioProcessFn);
mpProcessingTh->Start();
// start output thread
if (mHasOutput)
{
mpOutputTh = new nuiAudioDevice_DS_OutputTh(this, mNotifInputEvent[0], mNotifInputEvent[1], mNotifOutputEvent[0], mNotifOutputEvent[1]);
mpOutputTh->Start();
hr = mpOutputBuffer->Play(0,0,DSCBSTART_LOOPING);
if (FAILED(hr))
NGL_LOG(_T("nuiAudioDevice_DirectSound"), NGL_LOG_ERROR, _T("OutputBuffer->Play ERROR!\n"));
}
// start input capture
if (mHasInput)
{
hr = mpInputBuffer->Start(DSCBSTART_LOOPING);
if (FAILED(hr))
NGL_LOG(_T("nuiAudioDevice_DirectSound"), NGL_LOG_ERROR, _T("InputBuffer->Start ERROR!\n"));
}
return true;
}
void DXAudioInput::run() {
LPDIRECTSOUNDCAPTURE8 pDSCapture;
LPDIRECTSOUNDCAPTUREBUFFER pDSCaptureBuffer;
LPDIRECTSOUNDNOTIFY8 pDSNotify;
DWORD dwBufferSize;
bool bOk;
DWORD dwReadyBytes = 0;
DWORD dwLastReadPos = 0;
DWORD dwReadPosition;
DWORD dwCapturePosition;
LPVOID aptr1, aptr2;
DWORD nbytes1, nbytes2;
HRESULT hr;
WAVEFORMATEX wfx;
DSCBUFFERDESC dscbd;
pDSCapture = NULL;
pDSCaptureBuffer = NULL;
pDSNotify = NULL;
bOk = false;
bool failed = false;
float safety = 2.0f;
bool didsleep = false;
bool firstsleep = false;
Timer t;
ZeroMemory(&wfx, sizeof(wfx));
wfx.wFormatTag = WAVE_FORMAT_PCM;
ZeroMemory(&dscbd, sizeof(dscbd));
dscbd.dwSize = sizeof(dscbd);
dscbd.dwBufferBytes = dwBufferSize = iFrameSize * sizeof(short) * NBUFFBLOCKS;
dscbd.lpwfxFormat = &wfx;
wfx.nChannels = 1;
wfx.nSamplesPerSec = iSampleRate;
wfx.nBlockAlign = 2;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
wfx.wBitsPerSample = 16;
// Create IDirectSoundCapture using the preferred capture device
if (! g.s.qbaDXInput.isEmpty()) {
LPGUID lpguid = reinterpret_cast<LPGUID>(g.s.qbaDXInput.data());
if (FAILED(hr = DirectSoundCaptureCreate8(lpguid, &pDSCapture, NULL))) {
failed = true;
}
}
if (! pDSCapture && FAILED(hr = DirectSoundCaptureCreate8(&DSDEVID_DefaultVoiceCapture, &pDSCapture, NULL)))
qWarning("DXAudioInput: DirectSoundCaptureCreate failed: hr=0x%08lx", hr);
else if (FAILED(hr = pDSCapture->CreateCaptureBuffer(&dscbd, &pDSCaptureBuffer, NULL)))
qWarning("DXAudioInput: CreateCaptureBuffer failed: hr=0x%08lx", hr);
else if (FAILED(hr = pDSCaptureBuffer->QueryInterface(IID_IDirectSoundNotify, reinterpret_cast<void **>(&pDSNotify))))
qWarning("DXAudioInput: QueryInterface (Notify) failed: hr=0x%08lx", hr);
else
bOk = true;
if (failed)
g.mw->msgBox(tr("Opening chosen DirectSound Input failed. Default device will be used."));
qWarning("DXAudioInput: Initialized");
if (! bOk)
goto cleanup;
if (FAILED(hr = pDSCaptureBuffer->Start(DSCBSTART_LOOPING))) {
qWarning("DXAudioInput: Start failed: hr=0x%08lx", hr);
} else {
while (bRunning) {
firstsleep = true;
didsleep = false;
do {
if (FAILED(hr = pDSCaptureBuffer->GetCurrentPosition(&dwCapturePosition, &dwReadPosition))) {
qWarning("DXAudioInput: GetCurrentPosition failed: hr=0x%08lx", hr);
bRunning = false;
break;
}
if (dwReadPosition < dwLastReadPos)
dwReadyBytes = (dwBufferSize - dwLastReadPos) + dwReadPosition;
else
dwReadyBytes = dwReadPosition - dwLastReadPos;
if (static_cast<int>(dwReadyBytes) < sizeof(short) * iFrameSize) {
double msecleft = 20.0 - (dwReadyBytes * 20.0) / (sizeof(short) * iFrameSize);
if (didsleep)
safety *= 1.1f;
else if (firstsleep)
safety *= 0.998f;
int msec = static_cast<int>(msecleft + (firstsleep ? safety : 0.0));
msleep(msec);
didsleep = true;
firstsleep = false;
}
} while (static_cast<int>(dwReadyBytes) < sizeof(short) * iFrameSize);
// Desynchonized?
if (dwReadyBytes > (dwBufferSize / 2)) {
qWarning("DXAudioInput: Lost synchronization");
dwLastReadPos = dwReadPosition;
} else if (bRunning) {
if (FAILED(hr = pDSCaptureBuffer->Lock(dwLastReadPos, sizeof(short) * iFrameSize, &aptr1, &nbytes1, &aptr2, &nbytes2, 0))) {
qWarning("DXAudioInput: Lock from %ld (%d bytes) failed: hr=0x%08lx",dwLastReadPos, sizeof(short) * iFrameSize, hr);
bRunning = false;
break;
}
if (aptr1 && nbytes1)
CopyMemory(psMic, aptr1, nbytes1);
if (aptr2 && nbytes2)
CopyMemory(psMic+nbytes1/2, aptr2, nbytes2);
if (FAILED(hr = pDSCaptureBuffer->Unlock(aptr1, nbytes1, aptr2, nbytes2))) {
qWarning("DXAudioInput: Unlock failed: hr=0x%08lx", hr);
bRunning = false;
break;
}
dwLastReadPos = (dwLastReadPos + sizeof(short) * iFrameSize) % dwBufferSize;
encodeAudioFrame();
}
}
if (! FAILED(hr))
pDSCaptureBuffer->Stop();
}
if (FAILED(hr)) {
g.mw->msgBox(tr("Lost DirectSound input device."));
}
cleanup:
if (! bOk) {
g.mw->msgBox(tr("Opening chosen DirectSound Input device failed. No microphone capture will be done."));
}
if (pDSNotify)
pDSNotify->Release();
if (pDSCaptureBuffer)
pDSCaptureBuffer->Release();
if (pDSCapture)
pDSCapture->Release();
}
bool DSoundVoiceAdapter::SetupOutgoingBuffer()
{
HRESULT hr;
//
//
// Create the buffer for outgoing sound
//
//
if (FAILED(hr=DirectSoundCaptureCreate8(NULL, &dsC, NULL)))
{
DXTRACE_ERR_MSGBOX(L"DirectSoundCaptureCreate8", hr);
return false;
}
// Set up WAV format structure.
WAVEFORMATEX wfx;
memset(&wfx, 0, sizeof(WAVEFORMATEX));
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 1;
wfx.nSamplesPerSec = rakVoice->GetSampleRate();
wfx.nBlockAlign = 2;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
wfx.wBitsPerSample = 16;
// Set up DSCBUFFERDESC structure.
DSCBUFFERDESC dscbd;
memset(&dscbd, 0, sizeof(DSCBUFFERDESC));
dscbd.dwSize = sizeof(DSCBUFFERDESC);
dscbd.dwFlags = 0;
dscbd.dwBufferBytes = rakVoice->GetBufferSizeBytes()*FRAMES_IN_SOUND;
dscbd.dwReserved = 0;
dscbd.lpwfxFormat = &wfx;
dscbd.dwFXCount = 0;
dscbd.lpDSCFXDesc = NULL;
// Create capture buffer.
LPDIRECTSOUNDCAPTUREBUFFER pDscb = NULL;
if (FAILED(hr = dsC->CreateCaptureBuffer(&dscbd, &pDscb, NULL)))
{
DXTRACE_ERR_MSGBOX(L"IDirectSoundCapture8::CreateCaptureBuffer, when creating buffer for outgoing sound )", hr);
return false;
}
hr = pDscb->QueryInterface(IID_IDirectSoundCaptureBuffer8, (LPVOID*) &dsbOutgoing);
pDscb->Release();
if (FAILED(hr))
{
DXTRACE_ERR_MSGBOX(L"IDirectSoundBuffer::QueryInterface, when getting IDirectSoundCaptureBuffer8 interface for outgoing sound", hr);
return false;
}
//
// Setup the notification events
//
for (int i=0; i<FRAMES_IN_SOUND; i++)
{
outgoingBufferNotifications[i].dwOffset = i*rakVoice->GetBufferSizeBytes();
if ((outgoingBufferNotifications[i].hEventNotify = CreateEventEx(0, 0, CREATE_EVENT_MANUAL_RESET, 0))==NULL)
{
DXTRACE_ERR_MSGBOX(L"CreateEvent", GetLastError());
return false;
}
}
IDirectSoundNotify8 *dsbNotify=0;
if (FAILED(hr=dsbOutgoing->QueryInterface(IID_IDirectSoundNotify8, (LPVOID*) &dsbNotify)))
{
DXTRACE_ERR_MSGBOX(L"IDirectSoundCaptureBuffer8::QueryInterface, when getting IDirectSoundNotify8 interface for outgoing sound", hr);
return false;
}
hr = dsbNotify->SetNotificationPositions(FRAMES_IN_SOUND, outgoingBufferNotifications);
dsbNotify->Release();
if (FAILED(hr))
{
DXTRACE_ERR_MSGBOX(L"IDirectSoundNotify8::SetNotificationPositions, when setting notifications for outgoing sound", hr);
return false;
}
if (FAILED(hr = dsbOutgoing->Start(DSCBSTART_LOOPING)))
{
DXTRACE_ERR_MSGBOX(L"IDirectSoundCaptureBuffer8::Start, when starting outgoing sound buffer", hr);
return false;
}
return true;
}
bool SoundRecoder::createBuffer(LPGUID guid)
{
//デバイスの作成
HMODULE library = LoadLibraryA("dsound.dll");
if(!library)
return false;
HRESULT (WINAPI *DirectSoundCaptureCreate8)(LPCGUID,LPDIRECTSOUNDCAPTURE8*,LPUNKNOWN) =
(HRESULT (WINAPI *)(LPCGUID,LPDIRECTSOUNDCAPTURE8*,LPUNKNOWN))
GetProcAddress(library,"DirectSoundCaptureCreate8");
DirectSoundCaptureCreate8(guid,&m_soundCapture,NULL);
FreeLibrary(library);
//デバイスが作成できなかったら終了
if(!m_soundCapture)
return false;
if(m_soundCaptureBuffer)
{
m_soundCaptureBuffer->Release();
m_soundCaptureBuffer = NULL;
}
DSCBUFFERDESC dscbd;
WAVEFORMATEX wfx =
{
WAVE_FORMAT_PCM,
m_bufferChannel,
m_bufferRate,
m_bufferRate*m_bufferChannel*m_bufferBit/8,
m_bufferChannel*m_bufferBit/8,
m_bufferBit, 0
};
m_bufferSize = wfx.nAvgBytesPerSec*m_bufferMSec/1000;
dscbd.dwSize = sizeof(DSCBUFFERDESC);
dscbd.dwFlags = 0;
dscbd.dwBufferBytes = m_bufferSize;
dscbd.dwReserved = 0;
dscbd.lpwfxFormat = &wfx;
dscbd.dwFXCount = 0;
dscbd.lpDSCFXDesc = NULL;
m_latency = m_bufferSize / m_notifyCount;
LPDIRECTSOUNDCAPTUREBUFFER soundBuffer = NULL;
m_soundCapture->CreateCaptureBuffer(&dscbd, &soundBuffer, NULL);
if(!soundBuffer)
return false;
soundBuffer->QueryInterface(IID_IDirectSoundCaptureBuffer8,(LPVOID*)&m_soundCaptureBuffer);
soundBuffer->Release();
if(!m_soundCaptureBuffer)
return false;
INT i;
for(i=0;i<m_notifyCount;i++)
{
m_positionNotify[i].dwOffset = (dscbd.dwBufferBytes /m_notifyCount)*i ;
}
LPDIRECTSOUNDNOTIFY8 dsNotify;
m_soundCaptureBuffer->QueryInterface(IID_IDirectSoundNotify, (LPVOID*)&dsNotify);
dsNotify->SetNotificationPositions(m_notifyCount, m_positionNotify);
dsNotify->Release();
return true;
}
bool FVoiceCaptureWindows::Init(int32 SampleRate, int32 NumChannels)
{
if (SampleRate < 8000 || SampleRate > 48000)
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Voice capture doesn't support %d hz"), SampleRate);
return false;
}
if (NumChannels < 0 || NumChannels > 2)
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Voice capture only supports 1 or 2 channels"));
return false;
}
FVoiceCaptureDeviceWindows* VoiceDev = FVoiceCaptureDeviceWindows::Get();
if (!VoiceDev)
{
UE_LOG(LogVoiceCapture, Warning, TEXT("No voice capture interface."));
return false;
}
// DSDEVID_DefaultCapture WAVEINCAPS
HRESULT hr = DirectSoundCaptureCreate8(&DSDEVID_DefaultVoiceCapture, &CV->VoiceCaptureDev, NULL);
if (FAILED(hr))
{
//DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION, DSERR_OUTOFMEMORY
UE_LOG(LogVoiceCapture, Warning, TEXT("Failed to create capture device 0x%08x"), hr);
return false;
}
// Device capabilities
CV->VoiceCaptureDevCaps.dwSize = sizeof(DSCCAPS);
hr = CV->VoiceCaptureDev->GetCaps(&CV->VoiceCaptureDevCaps);
if (FAILED(hr))
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Failed to get mic device caps 0x%08x"), hr);
return false;
}
// Wave format setup
CV->WavFormat.wFormatTag = WAVE_FORMAT_PCM;
CV->WavFormat.nChannels = NumChannels;
CV->WavFormat.wBitsPerSample = 16;
CV->WavFormat.nSamplesPerSec = SampleRate;
CV->WavFormat.nBlockAlign = (CV->WavFormat.nChannels * CV->WavFormat.wBitsPerSample) / 8;
CV->WavFormat.nAvgBytesPerSec = CV->WavFormat.nBlockAlign * CV->WavFormat.nSamplesPerSec;
CV->WavFormat.cbSize = 0;
// Buffer setup
CV->VoiceCaptureBufferDesc.dwSize = sizeof(DSCBUFFERDESC);
CV->VoiceCaptureBufferDesc.dwFlags = 0;
CV->VoiceCaptureBufferDesc.dwBufferBytes = CV->WavFormat.nAvgBytesPerSec / 2; // .5 sec buffer
CV->VoiceCaptureBufferDesc.dwReserved = 0;
CV->VoiceCaptureBufferDesc.lpwfxFormat = &CV->WavFormat;
CV->VoiceCaptureBufferDesc.dwFXCount = 0;
CV->VoiceCaptureBufferDesc.lpDSCFXDesc = NULL;
LPDIRECTSOUNDCAPTUREBUFFER VoiceBuffer = NULL;
hr = CV->VoiceCaptureDev->CreateCaptureBuffer(&CV->VoiceCaptureBufferDesc, &VoiceBuffer, NULL);
if (FAILED(hr))
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Failed to create voice capture buffer 0x%08x"), hr);
return false;
}
hr = VoiceBuffer->QueryInterface(IID_IDirectSoundCaptureBuffer8, (LPVOID*)&CV->VoiceCaptureBuffer8);
VoiceBuffer->Release();
VoiceBuffer = NULL;
if (FAILED(hr))
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Failed to create voice capture buffer 0x%08x"), hr);
return false;
}
CV->VoiceCaptureBufferCaps8.dwSize = sizeof(DSCBCAPS);
hr = CV->VoiceCaptureBuffer8->GetCaps(&CV->VoiceCaptureBufferCaps8);
if (FAILED(hr))
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Failed to get voice buffer caps 0x%08x"), hr);
return false;
}
// TEST ------------------------
if (0)
{
DWORD SizeWritten8 = 0;
CV->VoiceCaptureBuffer8->GetFormat(NULL, sizeof(WAVEFORMATEX), &SizeWritten8);
LPWAVEFORMATEX BufferFormat8 = (WAVEFORMATEX*)FMemory::Malloc(SizeWritten8);
CV->VoiceCaptureBuffer8->GetFormat(BufferFormat8, SizeWritten8, &SizeWritten8);
FMemory::Free(BufferFormat8);
}
// TEST ------------------------
if (!CreateNotifications(CV->VoiceCaptureBufferCaps8.dwBufferBytes))
{
UE_LOG(LogVoiceCapture, Warning, TEXT("Failed to create voice buffer notifications"));
return false;
}
VoiceCaptureState = EVoiceCaptureState::NotCapturing;
return true;
}
bool VoiceRecord_DSound::Init(int sampleRate)
{
HRESULT hr;
DSCBUFFERDESC dscDesc;
DirectSoundCaptureCreateFn createFn;
Term();
WAVEFORMATEX recordFormat =
{
WAVE_FORMAT_PCM, // wFormatTag
1, // nChannels
sampleRate, // nSamplesPerSec
sampleRate*2, // nAvgBytesPerSec
2, // nBlockAlign
16, // wBitsPerSample
sizeof(WAVEFORMATEX) // cbSize
};
// Load the DSound DLL.
m_hInstDS = LoadLibrary("dsound.dll");
if(!m_hInstDS)
goto HandleError;
createFn = (DirectSoundCaptureCreateFn)GetProcAddress(m_hInstDS, "DirectSoundCaptureCreate");
if(!createFn)
goto HandleError;
hr = createFn(NULL, &m_pCapture, NULL);
if(FAILED(hr))
goto HandleError;
// Create the capture buffer.
memset(&dscDesc, 0, sizeof(dscDesc));
dscDesc.dwSize = sizeof(dscDesc);
dscDesc.dwFlags = 0;
dscDesc.dwBufferBytes = recordFormat.nAvgBytesPerSec;
dscDesc.lpwfxFormat = &recordFormat;
hr = m_pCapture->CreateCaptureBuffer(&dscDesc, &m_pCaptureBuffer, NULL);
if(FAILED(hr))
goto HandleError;
// Figure out how many bytes we got in our capture buffer.
DSCBCAPS caps;
memset(&caps, 0, sizeof(caps));
caps.dwSize = sizeof(caps);
hr = m_pCaptureBuffer->GetCaps(&caps);
if(FAILED(hr))
goto HandleError;
m_nCaptureBufferBytes = caps.dwBufferBytes;
// Set it up so we get notification when the buffer wraps.
m_hWrapEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if(!m_hWrapEvent)
goto HandleError;
DSBPOSITIONNOTIFY dsbNotify;
dsbNotify.dwOffset = dscDesc.dwBufferBytes - 1;
dsbNotify.hEventNotify = m_hWrapEvent;
// Get the IDirectSoundNotify interface.
LPDIRECTSOUNDNOTIFY pNotify;
hr = m_pCaptureBuffer->QueryInterface(IID_IDirectSoundNotify, (void**)&pNotify);
if(FAILED(hr))
goto HandleError;
hr = pNotify->SetNotificationPositions(1, &dsbNotify);
pNotify->Release();
if(FAILED(hr))
goto HandleError;
// Start capturing.
hr = m_pCaptureBuffer->Start(DSCBSTART_LOOPING);
if(FAILED(hr))
return false;
return true;
HandleError:;
Term();
return false;
}
bool FVoiceCaptureWindows::Init(int32 SampleRate, int32 NumChannels)
{
if (SampleRate < 8000 || SampleRate > 48000)
{
UE_LOG(LogVoice, Warning, TEXT("Voice capture doesn't support %d hz"), SampleRate);
return false;
}
if (NumChannels < 0 || NumChannels > 2)
{
UE_LOG(LogVoice, Warning, TEXT("Voice capture only supports 1 or 2 channels"));
return false;
}
// @todo move this to voice module (only init/deinit once ever)
if (FAILED(DirectSoundCreate8(NULL, &DirectSound, NULL)))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to init DirectSound"));
return false;
}
if (FAILED(DirectSoundCaptureEnumerate((LPDSENUMCALLBACK)CaptureDeviceCallback, this)))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to enumerate devices"));
return false;
}
// DSDEVID_DefaultCapture WAVEINCAPS
if (FAILED(DirectSoundCaptureCreate8(&DSDEVID_DefaultVoiceCapture, &VoiceCaptureDev, NULL)))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to create capture device"));
return false;
}
// Device capabilities
VoiceCaptureDevCaps.dwSize = sizeof(DSCCAPS);
if (FAILED(VoiceCaptureDev->GetCaps(&VoiceCaptureDevCaps)))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to get mic device caps"));
return false;
}
// Wave format setup
WavFormat.wFormatTag = WAVE_FORMAT_PCM;
WavFormat.nChannels = NumChannels;
WavFormat.wBitsPerSample = 16;
WavFormat.nSamplesPerSec = SampleRate;
WavFormat.nBlockAlign = (WavFormat.nChannels * WavFormat.wBitsPerSample) / 8;
WavFormat.nAvgBytesPerSec = WavFormat.nBlockAlign * WavFormat.nSamplesPerSec;
WavFormat.cbSize = 0;
// Buffer setup
VoiceCaptureBufferDesc.dwSize = sizeof(DSCBUFFERDESC);
VoiceCaptureBufferDesc.dwFlags = 0;
VoiceCaptureBufferDesc.dwBufferBytes = WavFormat.nAvgBytesPerSec / 2; // .5 sec buffer
VoiceCaptureBufferDesc.dwReserved = 0;
VoiceCaptureBufferDesc.lpwfxFormat = &WavFormat;
VoiceCaptureBufferDesc.dwFXCount = 0;
VoiceCaptureBufferDesc.lpDSCFXDesc = NULL;
LPDIRECTSOUNDCAPTUREBUFFER VoiceBuffer = NULL;
if (FAILED(VoiceCaptureDev->CreateCaptureBuffer(&VoiceCaptureBufferDesc, &VoiceBuffer, NULL)))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to create voice capture buffer"));
return false;
}
HRESULT BufferCreateHR = VoiceBuffer->QueryInterface(IID_IDirectSoundCaptureBuffer8, (LPVOID*)&VoiceCaptureBuffer8);
VoiceBuffer->Release();
VoiceBuffer = NULL;
if (FAILED(BufferCreateHR))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to create voice capture buffer"));
return false;
}
VoiceCaptureBufferCaps8.dwSize = sizeof(DSCBCAPS);
if (FAILED(VoiceCaptureBuffer8->GetCaps(&VoiceCaptureBufferCaps8)))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to get voice buffer caps"));
return false;
}
// TEST ------------------------
if (0)
{
DWORD SizeWritten8 = 0;
VoiceCaptureBuffer8->GetFormat(NULL, sizeof(WAVEFORMATEX), &SizeWritten8);
LPWAVEFORMATEX BufferFormat8 = (WAVEFORMATEX*)FMemory::Malloc(SizeWritten8);
VoiceCaptureBuffer8->GetFormat(BufferFormat8, SizeWritten8, &SizeWritten8);
FMemory::Free(BufferFormat8);
}
// TEST ------------------------
if (!CreateNotifications(VoiceCaptureBufferCaps8.dwBufferBytes))
{
UE_LOG(LogVoice, Warning, TEXT("Failed to create voice buffer notifications"));
return false;
}
VoiceCaptureState = EVoiceCaptureState::NotCapturing;
return true;
}