static void capture_free (void)
{
if (lpDSB2r) {
lpDSB2r->Stop ();
lpDSB2r->Release ();
write_log (_T("SAMPLER: Parallel port sampler freed\n"));
}
lpDSB2r = NULL;
if (lpDS2r)
lpDS2r->Release ();
lpDS2r = NULL;
xfree (samplebuffer);
samplebuffer = NULL;
}
void VoiceRecord_DSound::Term()
{
if(m_pCaptureBuffer)
m_pCaptureBuffer->Release();
if(m_pCapture)
m_pCapture->Release();
if(m_hWrapEvent)
DeleteObject(m_hWrapEvent);
if(m_hInstDS)
{
FreeLibrary(m_hInstDS);
m_hInstDS = NULL;
}
Clear();
}
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::Close()
{
if (mpOutputBuffer)
{
mpOutputBuffer->Stop();
}
if (mpInputBuffer)
{
mpInputBuffer->Stop();
}
if (mpProcessingTh)
{
mpProcessingTh->Stop();
mpProcessingTh->Join();
delete mpProcessingTh;
mpProcessingTh = NULL;
}
if (mpOutputTh)
{
mpOutputTh->Stop();
mpOutputTh->Join();
delete mpOutputTh;
mpOutputTh = NULL;
}
if (mpOutputBuffer)
{
mpOutputBuffer->Release();
mpOutputBuffer=NULL;
}
if (mpInputBuffer)
{
mpInputBuffer->Release();
mpInputBuffer=NULL;
}
delete mpRingBuffer;
mpRingBuffer = NULL;
if (mNotifInputEvent[0])
{
CloseHandle(mNotifInputEvent[0]);
mNotifInputEvent[0] = NULL;
}
if (mNotifInputEvent[1])
{
CloseHandle(mNotifInputEvent[1]);
mNotifInputEvent[1] = NULL;
}
if (mNotifOutputEvent[0])
{
CloseHandle(mNotifOutputEvent[0]);
mNotifOutputEvent[0] = NULL;
}
if (mNotifOutputEvent[1])
{
CloseHandle(mNotifOutputEvent[1]);
mNotifOutputEvent[1] = NULL;
}
return false;
}
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 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;
}