static int capture_init (void)
{
HRESULT hr;
DSCBUFFERDESC sound_buffer_rec;
WAVEFORMATEX wavfmt;
TCHAR *name;
int samplerate = 44100;
if (currprefs.sampler_freq)
samplerate = currprefs.sampler_freq;
name = record_devices[currprefs.win32_samplersoundcard]->name;
wavfmt.wFormatTag = WAVE_FORMAT_PCM;
wavfmt.nChannels = 2;
wavfmt.nSamplesPerSec = samplerate;
wavfmt.wBitsPerSample = 16;
wavfmt.nBlockAlign = wavfmt.wBitsPerSample / 8 * wavfmt.nChannels;
wavfmt.nAvgBytesPerSec = wavfmt.nBlockAlign * wavfmt.nSamplesPerSec;
wavfmt.cbSize = 0;
clockspersample = sampler_evtime / samplerate;
sampleframes = (samplerate + 49) / 50;
recordbufferframes = 16384;
if (currprefs.sampler_buffer)
recordbufferframes = currprefs.sampler_buffer;
hr = DirectSoundCaptureCreate (&record_devices[currprefs.win32_samplersoundcard]->guid, &lpDS2r, NULL);
if (FAILED (hr)) {
write_log (_T("SAMPLER: DirectSoundCaptureCreate('%s') failure: %s\n"), name, DXError (hr));
return 0;
}
memset (&sound_buffer_rec, 0, sizeof (DSCBUFFERDESC));
sound_buffer_rec.dwSize = sizeof (DSCBUFFERDESC);
sound_buffer_rec.dwBufferBytes = recordbufferframes * SAMPLESIZE;
sound_buffer_rec.lpwfxFormat = &wavfmt;
sound_buffer_rec.dwFlags = 0 ;
hr = lpDS2r->CreateCaptureBuffer (&sound_buffer_rec, &lpDSB2r, NULL);
if (FAILED (hr)) {
write_log (_T("SAMPLER: CreateCaptureSoundBuffer('%s') failure: %s\n"), name, DXError(hr));
return 0;
}
hr = lpDSB2r->Start (DSCBSTART_LOOPING);
if (FAILED (hr)) {
write_log (_T("SAMPLER: DirectSoundCaptureBuffer_Start('%s') failed: %s\n"), name, DXError (hr));
return 0;
}
samplebuffer = xcalloc (uae_u8, sampleframes * SAMPLESIZE);
write_log (_T("SAMPLER: Parallel port sampler initialized, CPS=%f, '%s'\n"), clockspersample, name);
return 1;
}
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 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;
}
int audioStreamer_ds::Read(char *buf, int len) // returns 0 if blocked, < 0 if error, > 0 if data
{
if (!m_inbuf) return -1;
if (!m_has_started)
{
m_inbuf->Start(DSCBSTART_LOOPING);
m_has_started=1;
}
int cappos;
m_inbuf->GetCurrentPosition(NULL,(DWORD *)&cappos);
if (cappos < m_last_pos) m_i_dw++;
m_last_pos=cappos;
if ((m_i_dw - m_i_lw) * m_totalbufsize + cappos - m_bufpos >= (unsigned int)m_totalbufsize/2) // detect overrun, set to cappos
{
m_i_lw=m_i_dw;
m_bufpos=0;
while (m_bufpos < cappos-m_bufsize) m_bufpos += m_bufsize;
if (m_bufpos >= m_totalbufsize)
{
m_i_lw++;
m_bufpos -= m_totalbufsize;
}
// audiostream_onover();
}
for (;;)
{
if (m_i_lw < m_i_dw || m_bufpos + m_bufsize < cappos) break;
Sleep(DS_SLEEP);
m_inbuf->GetCurrentPosition(NULL,(DWORD*)&cappos);
if (cappos < m_last_pos) m_i_dw++;
m_last_pos=cappos;
}
//audiostream_instance->g_sound_in_overruns = (m_i_lw < m_i_dw ? (m_totalbufsize+cappos) : cappos ) -m_bufpos;
void *v1=0, *v2=0;
DWORD lv1=0, lv2=0;
if (m_inbuf->Lock(m_bufpos,len,&v1,&lv1,&v2,&lv2,FALSE) == DS_OK)
{
int l1=min((int)lv1,len);
memcpy(buf,v1,l1);
if (l1 < len && v2 && lv2) memcpy(buf+l1,v2,min((int)lv2,len-l1));
m_inbuf->Unlock(v1,lv1,v2,lv2);
m_bufpos += len;
if (m_bufpos >= m_totalbufsize)
{
m_i_lw++;
m_bufpos -= m_totalbufsize;
}
}
else
{
return -1;
}
return len;
}