static void capturebuffer_destroy(IDirectSoundCaptureBufferImpl *This)
{
if (This->device->state == STATE_CAPTURING)
This->device->state = STATE_STOPPING;
if(This->thread){
SetEvent(This->sleepev);
WaitForSingleObject(This->thread, INFINITE);
CloseHandle(This->thread);
}
CloseHandle(This->sleepev);
HeapFree(GetProcessHeap(),0, This->pdscbd);
if (This->device->client) {
IAudioClient_Release(This->device->client);
This->device->client = NULL;
}
if (This->device->capture) {
IAudioCaptureClient_Release(This->device->capture);
This->device->capture = NULL;
}
/* remove from DirectSoundCaptureDevice */
This->device->capture_buffer = NULL;
HeapFree(GetProcessHeap(), 0, This->notifies);
HeapFree(GetProcessHeap(), 0, This);
TRACE("(%p) released\n", This);
}
static void capturebuffer_destroy(IDirectSoundCaptureBufferImpl *This)
{
if (This->device->state == STATE_CAPTURING)
This->device->state = STATE_STOPPING;
HeapFree(GetProcessHeap(),0, This->pdscbd);
if (This->device->client) {
IAudioClient_Release(This->device->client);
This->device->client = NULL;
}
if (This->device->capture) {
IAudioCaptureClient_Release(This->device->capture);
This->device->capture = NULL;
}
/* remove from DirectSoundCaptureDevice */
This->device->capture_buffer = NULL;
HeapFree(GetProcessHeap(), 0, This->notifies);
HeapFree(GetProcessHeap(), 0, This);
TRACE("(%p) released\n", This);
}
static HRESULT IDirectSoundCaptureBufferImpl_Create(
DirectSoundCaptureDevice *device,
IDirectSoundCaptureBufferImpl ** ppobj,
LPCDSCBUFFERDESC lpcDSCBufferDesc)
{
LPWAVEFORMATEX wfex;
IDirectSoundCaptureBufferImpl *This;
TRACE( "(%p,%p,%p)\n", device, ppobj, lpcDSCBufferDesc);
if (ppobj == NULL) {
WARN("invalid parameter: ppobj == NULL\n");
return DSERR_INVALIDPARAM;
}
*ppobj = NULL;
if (!device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (lpcDSCBufferDesc == NULL) {
WARN("invalid parameter: lpcDSCBufferDesc == NULL\n");
return DSERR_INVALIDPARAM;
}
if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) &&
(lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) ||
(lpcDSCBufferDesc->dwBufferBytes == 0) ||
(lpcDSCBufferDesc->lpwfxFormat == NULL) ) { /* FIXME: DSERR_BADFORMAT ? */
WARN("invalid lpcDSCBufferDesc\n");
return DSERR_INVALIDPARAM;
}
wfex = lpcDSCBufferDesc->lpwfxFormat;
TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
"bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
wfex->nAvgBytesPerSec, wfex->nBlockAlign,
wfex->wBitsPerSample, wfex->cbSize);
device->pwfx = DSOUND_CopyFormat(wfex);
if ( device->pwfx == NULL )
return DSERR_OUTOFMEMORY;
This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
sizeof(IDirectSoundCaptureBufferImpl));
if ( This == NULL ) {
WARN("out of memory\n");
return DSERR_OUTOFMEMORY;
} else {
HRESULT err = DS_OK;
LPBYTE newbuf;
DWORD buflen;
This->numIfaces = 0;
This->ref = 0;
This->refn = 0;
This->device = device;
This->device->capture_buffer = This;
This->nrofnotifies = 0;
This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
lpcDSCBufferDesc->dwSize);
if (This->pdscbd)
CopyMemory(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);
else {
WARN("no memory\n");
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return DSERR_OUTOFMEMORY;
}
This->IDirectSoundCaptureBuffer8_iface.lpVtbl = &dscbvt;
This->IDirectSoundNotify_iface.lpVtbl = &dscnvt;
err = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,
CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);
if(FAILED(err)){
WARN("Activate failed: %08x\n", err);
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return err;
}
err = IAudioClient_Initialize(device->client,
AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST,
200 * 100000, 50000, device->pwfx, NULL);
if(FAILED(err)){
WARN("Initialize failed: %08x\n", err);
IAudioClient_Release(device->client);
device->client = NULL;
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
if(err == AUDCLNT_E_UNSUPPORTED_FORMAT)
return DSERR_BADFORMAT;
return err;
}
err = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,
(void**)&device->capture);
if(FAILED(err)){
WARN("GetService failed: %08x\n", err);
IAudioClient_Release(device->client);
device->client = NULL;
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return err;
}
buflen = lpcDSCBufferDesc->dwBufferBytes;
TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
if (device->buffer)
newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
else
newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
if (newbuf == NULL) {
IAudioClient_Release(device->client);
device->client = NULL;
IAudioCaptureClient_Release(device->capture);
device->capture = NULL;
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return DSERR_OUTOFMEMORY;
}
device->buffer = newbuf;
device->buflen = buflen;
}
IDirectSoundCaptureBuffer_AddRef(&This->IDirectSoundCaptureBuffer8_iface);
*ppobj = This;
TRACE("returning DS_OK\n");
return DS_OK;
}
JNIEXPORT void JNICALL
Java_org_jitsi_impl_neomedia_jmfext_media_protocol_wasapi_WASAPI_IAudioCaptureClient_1Release
(JNIEnv *env, jclass clazz, jlong thiz)
{
IAudioCaptureClient_Release((IAudioCaptureClient *) (intptr_t) thiz);
}
static void test_marshal(void)
{
IStream *pStream;
IAudioClient *ac, *acDest;
IAudioCaptureClient *cc, *ccDest;
WAVEFORMATEX *pwfx;
HRESULT hr;
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ac);
ok(hr == S_OK, "Activation failed with %08x\n", hr);
if(hr != S_OK)
return;
hr = IAudioClient_GetMixFormat(ac, &pwfx);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
0, pwfx, NULL);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
CoTaskMemFree(pwfx);
hr = IAudioClient_GetService(ac, &IID_IAudioCaptureClient, (void**)&cc);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
if(hr != S_OK) {
IAudioClient_Release(ac);
return;
}
hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
ok(hr == S_OK, "CreateStreamOnHGlobal failed 0x%08x\n", hr);
/* marshal IAudioClient */
hr = CoMarshalInterface(pStream, &IID_IAudioClient, (IUnknown*)ac, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
ok(hr == S_OK, "CoMarshalInterface IAudioClient failed 0x%08x\n", hr);
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoUnmarshalInterface(pStream, &IID_IAudioClient, (void **)&acDest);
ok(hr == S_OK, "CoUnmarshalInterface IAudioClient failed 0x%08x\n", hr);
if (hr == S_OK)
IAudioClient_Release(acDest);
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
/* marshal IAudioCaptureClient */
hr = CoMarshalInterface(pStream, &IID_IAudioCaptureClient, (IUnknown*)cc, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
ok(hr == S_OK, "CoMarshalInterface IAudioCaptureClient failed 0x%08x\n", hr);
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoUnmarshalInterface(pStream, &IID_IAudioCaptureClient, (void **)&ccDest);
ok(hr == S_OK, "CoUnmarshalInterface IAudioCaptureClient failed 0x%08x\n", hr);
if (hr == S_OK)
IAudioCaptureClient_Release(ccDest);
IStream_Release(pStream);
IAudioClient_Release(ac);
IAudioCaptureClient_Release(cc);
}
static void test_capture(IAudioClient *ac, HANDLE handle, WAVEFORMATEX *wfx)
{
IAudioCaptureClient *acc;
HRESULT hr;
UINT32 frames, next, pad, sum = 0;
BYTE *data;
DWORD flags;
UINT64 pos, qpc;
REFERENCE_TIME period;
hr = IAudioClient_GetService(ac, &IID_IAudioCaptureClient, (void**)&acc);
ok(hr == S_OK, "IAudioClient_GetService(IID_IAudioCaptureClient) returns %08x\n", hr);
if (hr != S_OK)
return;
frames = 0xabadcafe;
data = (void*)0xdeadf00d;
flags = 0xabadcafe;
pos = qpc = 0xdeadbeef;
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == AUDCLNT_S_BUFFER_EMPTY, "Initial IAudioCaptureClient_GetBuffer returns %08x\n", hr);
/* should be empty right after start. Otherwise consume one packet */
if(hr == S_OK){
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
sum += frames;
frames = 0xabadcafe;
data = (void*)0xdeadf00d;
flags = 0xabadcafe;
pos = qpc = 0xdeadbeef;
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == AUDCLNT_S_BUFFER_EMPTY, "Initial IAudioCaptureClient_GetBuffer returns %08x\n", hr);
}
if(hr == AUDCLNT_S_BUFFER_EMPTY){
ok(!frames, "frames changed to %u\n", frames);
ok(data == (void*)0xdeadf00d, "data changed to %p\n", data);
ok(flags == 0xabadcafe, "flags changed to %x\n", flags);
ok(pos == 0xdeadbeef, "position changed to %u\n", (UINT)pos);
ok(qpc == 0xdeadbeef, "timer changed to %u\n", (UINT)qpc);
/* GetNextPacketSize yields 0 if no data is yet available
* it is not constantly period_size * SamplesPerSec */
hr = IAudioCaptureClient_GetNextPacketSize(acc, &next);
ok(hr == S_OK, "IAudioCaptureClient_GetNextPacketSize returns %08x\n", hr);
ok(!next, "GetNextPacketSize %u\n", next);
}
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
sum += frames;
ok(ResetEvent(handle), "ResetEvent\n");
hr = IAudioCaptureClient_GetNextPacketSize(acc, &next);
ok(hr == S_OK, "IAudioCaptureClient_GetNextPacketSize returns %08x\n", hr);
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
ok(next == pad, "GetNextPacketSize %u vs. GCP %u\n", next, pad);
/* later GCP will grow, while GNPS is 0 or period size */
hr = IAudioCaptureClient_GetNextPacketSize(acc, NULL);
ok(hr == E_POINTER, "IAudioCaptureClient_GetNextPacketSize(NULL) returns %08x\n", hr);
data = (void*)0xdeadf00d;
frames = 0xdeadbeef;
flags = 0xabadcafe;
hr = IAudioCaptureClient_GetBuffer(acc, &data, NULL, NULL, NULL, NULL);
ok(hr == E_POINTER, "IAudioCaptureClient_GetBuffer(data, NULL, NULL) returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, NULL, &frames, NULL, NULL, NULL);
ok(hr == E_POINTER, "IAudioCaptureClient_GetBuffer(NULL, &frames, NULL) returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, NULL, NULL, &flags, NULL, NULL);
ok(hr == E_POINTER, "IAudioCaptureClient_GetBuffer(NULL, NULL, &flags) returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, NULL, NULL, NULL);
ok(hr == E_POINTER, "IAudioCaptureClient_GetBuffer(&ata, &frames, NULL) returns %08x\n", hr);
ok((DWORD_PTR)data == 0xdeadf00d, "data is reset to %p\n", data);
ok(frames == 0xdeadbeef, "frames is reset to %08x\n", frames);
ok(flags == 0xabadcafe, "flags is reset to %08x\n", flags);
hr = IAudioClient_GetDevicePeriod(ac, &period, NULL);
ok(hr == S_OK, "GetDevicePeriod failed: %08x\n", hr);
period = MulDiv(period, wfx->nSamplesPerSec, 10000000); /* as in render.c */
ok(WaitForSingleObject(handle, 1000) == WAIT_OBJECT_0, "Waiting on event handle failed!\n");
data = (void*)0xdeadf00d;
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == S_OK || hr == AUDCLNT_S_BUFFER_EMPTY, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
if (hr == S_OK){
ok(frames, "Amount of frames locked is 0!\n");
/* broken: some w7 machines return pad == 0 and DATA_DISCONTINUITY here,
* AUDCLNT_S_BUFFER_EMPTY above, yet pos == 1-2 * period rather than 0 */
ok(pos == sum || broken(pos == period || pos == 2*period),
"Position %u expected %u\n", (UINT)pos, sum);
sum = pos;
}else if (hr == AUDCLNT_S_BUFFER_EMPTY){
ok(!frames, "Amount of frames locked with empty buffer is %u!\n", frames);
ok(data == (void*)0xdeadf00d, "No data changed to %p\n", data);
}
trace("Wait'ed position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
hr = IAudioCaptureClient_GetNextPacketSize(acc, &next);
ok(hr == S_OK, "IAudioCaptureClient_GetNextPacketSize returns %08x\n", hr);
ok(next == frames, "GetNextPacketSize %u vs. GetBuffer %u\n", next, frames);
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
hr = IAudioCaptureClient_ReleaseBuffer(acc, 0);
ok(hr == S_OK, "Releasing 0 returns %08x\n", hr);
hr = IAudioCaptureClient_GetNextPacketSize(acc, &next);
ok(hr == S_OK, "IAudioCaptureClient_GetNextPacketSize returns %08x\n", hr);
if (frames) {
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == AUDCLNT_E_OUT_OF_ORDER, "Releasing buffer twice returns %08x\n", hr);
sum += frames;
}
Sleep(350); /* for sure there's data now */
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
/** GetNextPacketSize
* returns either 0 or one period worth of frames
* whereas GetCurrentPadding grows when input is not consumed. */
hr = IAudioCaptureClient_GetNextPacketSize(acc, &next);
ok(hr == S_OK, "IAudioCaptureClient_GetNextPacketSize returns %08x\n", hr);
ok(next < pad, "GetNextPacketSize %u vs. GCP %u\n", next, pad);
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == S_OK, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
ok(next == frames, "GetNextPacketSize %u vs. GetBuffer %u\n", next, frames);
if(hr == S_OK){
UINT32 frames2 = frames;
UINT64 pos2, qpc2;
ok(frames, "Amount of frames locked is 0!\n");
ok(pos == sum, "Position %u expected %u\n", (UINT)pos, sum);
hr = IAudioCaptureClient_ReleaseBuffer(acc, 0);
ok(hr == S_OK, "Releasing 0 returns %08x\n", hr);
/* GCP did not decrement, no data consumed */
hr = IAudioClient_GetCurrentPadding(ac, &frames);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
ok(frames == pad || frames == pad + next /* concurrent feeder */,
"GCP %u past ReleaseBuffer(0) initially %u\n", frames, pad);
/* should re-get the same data */
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos2, &qpc2);
ok(hr == S_OK, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
ok(frames2 == frames, "GetBuffer after ReleaseBuffer(0) %u/%u\n", frames2, frames);
ok(pos2 == pos, "Position after ReleaseBuffer(0) %u/%u\n", (UINT)pos2, (UINT)pos);
todo_wine ok(qpc2 == qpc, "HPC after ReleaseBuffer(0) %u vs. %u\n", (UINT)qpc2, (UINT)qpc);
}
/* trace after the GCP test because log output to MS-DOS console disturbs timing */
trace("Sleep.1 position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
if(hr == S_OK){
UINT32 frames2 = 0xabadcafe;
BYTE *data2 = (void*)0xdeadf00d;
flags = 0xabadcafe;
ok(pos == sum, "Position %u expected %u\n", (UINT)pos, sum);
pos = qpc = 0xdeadbeef;
hr = IAudioCaptureClient_GetBuffer(acc, &data2, &frames2, &flags, &pos, &qpc);
ok(hr == AUDCLNT_E_OUT_OF_ORDER, "Out of order IAudioCaptureClient_GetBuffer returns %08x\n", hr);
ok(frames2 == 0xabadcafe, "Out of order frames changed to %x\n", frames2);
ok(data2 == (void*)0xdeadf00d, "Out of order data changed to %p\n", data2);
ok(flags == 0xabadcafe, "Out of order flags changed to %x\n", flags);
ok(pos == 0xdeadbeef, "Out of order position changed to %x\n", (UINT)pos);
ok(qpc == 0xdeadbeef, "Out of order timer changed to %x\n", (UINT)qpc);
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames+1);
ok(hr == AUDCLNT_E_INVALID_SIZE, "Releasing buffer+1 returns %08x\n", hr);
hr = IAudioCaptureClient_ReleaseBuffer(acc, 1);
ok(hr == AUDCLNT_E_INVALID_SIZE, "Releasing 1 returns %08x\n", hr);
hr = IAudioClient_Reset(ac);
ok(hr == AUDCLNT_E_NOT_STOPPED, "Reset failed: %08x\n", hr);
}
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
if (frames) {
sum += frames;
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == AUDCLNT_E_OUT_OF_ORDER, "Releasing buffer twice returns %08x\n", hr);
}
frames = period;
ok(next == frames, "GetNextPacketSize %u vs. GetDevicePeriod %u\n", next, frames);
/* GetBufferSize is not a multiple of the period size! */
hr = IAudioClient_GetBufferSize(ac, &next);
ok(hr == S_OK, "GetBufferSize failed: %08x\n", hr);
trace("GetBufferSize %u period size %u\n", next, frames);
Sleep(400); /* overrun */
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == S_OK, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
trace("Overrun position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
if(hr == S_OK){
/* The discontinuity is reported here, but is this an old or new packet? */
todo_wine ok(flags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY, "expect DISCONTINUITY %x\n", flags);
ok(pad == next, "GCP %u vs. BufferSize %u\n", (UINT32)pad, next);
/* Native's position is one period further than what we read.
* Perhaps that's precisely the meaning of DATA_DISCONTINUITY:
* signal when the position jump left a gap. */
todo_wine ok(pos == sum + frames, "Position %u gap %d\n",
(UINT)pos, (UINT)pos - sum);
if(flags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY)
sum = pos;
}
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
sum += frames;
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == S_OK, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
trace("Cont'ed position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
if(hr == S_OK){
ok(pos == sum, "Position %u expected %u\n", (UINT)pos, sum);
ok(!flags, "flags %u\n", flags);
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
sum += frames;
}
hr = IAudioClient_Stop(ac);
ok(hr == S_OK, "Stop on a started stream returns %08x\n", hr);
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start on a stopped stream returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == S_OK, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
trace("Restart position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
ok(pad > sum, "restarted GCP %u\n", pad); /* GCP is still near buffer size */
if(frames){
ok(pos == sum, "Position %u expected %u\n", (UINT)pos, sum);
ok(!flags, "flags %u\n", flags);
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
sum += frames;
}
hr = IAudioClient_Stop(ac);
ok(hr == S_OK, "Stop on a started stream returns %08x\n", hr);
hr = IAudioClient_Reset(ac);
ok(hr == S_OK, "Reset on a stopped stream returns %08x\n", hr);
sum += pad - frames;
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start on a stopped stream returns %08x\n", hr);
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
flags = 0xabadcafe;
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == AUDCLNT_S_BUFFER_EMPTY || /*PulseAudio*/hr == S_OK,
"Initial IAudioCaptureClient_GetBuffer returns %08x\n", hr);
trace("Reset position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
if(hr == S_OK){
/* Only PulseAudio goes here; despite snd_pcm_drop it manages
* to fill GetBufferSize with a single snd_pcm_read */
trace("Test marked todo: only PulseAudio gets here\n");
todo_wine ok(flags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY, "expect DISCONTINUITY %x\n", flags);
/* Reset zeroes padding, not the position */
ok(pos >= sum, "Position %u last %u\n", (UINT)pos, sum);
/*sum = pos; check after next GetBuffer */
hr = IAudioCaptureClient_ReleaseBuffer(acc, frames);
ok(hr == S_OK, "Releasing buffer returns %08x\n", hr);
sum += frames;
}
else if(hr == AUDCLNT_S_BUFFER_EMPTY){
ok(!pad, "resetted GCP %u\n", pad);
Sleep(180);
}
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding call returns %08x\n", hr);
hr = IAudioCaptureClient_GetBuffer(acc, &data, &frames, &flags, &pos, &qpc);
ok(hr == S_OK, "Valid IAudioCaptureClient_GetBuffer returns %08x\n", hr);
trace("Running position %d pad %u flags %x, amount of frames locked: %u\n",
hr==S_OK ? (UINT)pos : -1, pad, flags, frames);
if(hr == S_OK){
/* Some w7 machines signal DATA_DISCONTINUITY here following the
* previous AUDCLNT_S_BUFFER_EMPTY, others not. What logic? */
ok(pos >= sum, "Position %u gap %d\n", (UINT)pos, (UINT)pos - sum);
IAudioCaptureClient_ReleaseBuffer(acc, frames);
}
IAudioCaptureClient_Release(acc);
}
