JNIEXPORT jint JNICALL
Java_org_jitsi_impl_neomedia_jmfext_media_protocol_wasapi_WASAPI_IAudioClient_1Initialize
(JNIEnv *env, jclass clazz, jlong thiz, jint shareMode, jint streamFlags,
jlong hnsBufferDuration, jlong hnsPeriodicity, jlong pFormat,
jstring audioSessionGuid)
{
HRESULT hr;
IID audioSessionGuid_;
hr = WASAPI_iidFromString(env, audioSessionGuid, &audioSessionGuid_);
if (SUCCEEDED(hr))
{
hr
= IAudioClient_Initialize(
(IAudioClient *) (intptr_t) thiz,
(AUDCLNT_SHAREMODE) shareMode,
(DWORD) streamFlags,
(REFERENCE_TIME) hnsBufferDuration,
(REFERENCE_TIME) hnsPeriodicity,
(const WAVEFORMATEX *) (intptr_t) pFormat,
&audioSessionGuid_);
if (FAILED(hr))
WASAPI_throwNewHResultException(env, hr, __func__, __LINE__);
}
return (jint) hr;
}
static void test_event(void)
{
HANDLE event;
HRESULT hr;
IAudioClient *ac;
WAVEFORMATEX *pwfx;
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);
if(hr != S_OK)
return;
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK, 5000000,
0, pwfx, NULL);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
CoTaskMemFree(pwfx);
event = CreateEventW(NULL, FALSE, FALSE, NULL);
ok(event != NULL, "CreateEvent failed\n");
hr = IAudioClient_Start(ac);
ok(hr == AUDCLNT_E_EVENTHANDLE_NOT_SET, "Start failed: %08x\n", hr);
hr = IAudioClient_SetEventHandle(ac, event);
ok(hr == S_OK, "SetEventHandle failed: %08x\n", hr);
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioClient_Stop(ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
/* test releasing a playing stream */
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
IAudioClient_Release(ac);
CloseHandle(event);
}
static void test_channelvolume(void)
{
IAudioClient *ac;
IChannelAudioVolume *acv;
WAVEFORMATEX *fmt;
UINT32 chans, i;
HRESULT hr;
float vol, *vols;
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, &fmt);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, NULL);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(ac, &IID_IChannelAudioVolume, (void**)&acv);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelCount(acv, NULL);
ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelCount(acv, &chans);
ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
ok(chans == fmt->nChannels, "GetChannelCount gave wrong number of channels: %d\n", chans);
hr = IChannelAudioVolume_GetChannelVolume(acv, fmt->nChannels, NULL);
ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelVolume(acv, fmt->nChannels, &vol);
ok(hr == E_INVALIDARG, "GetChannelCount gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelVolume(acv, 0, NULL);
ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelVolume(acv, 0, &vol);
ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
ok(vol == 1.f, "Channel volume was not 1: %f\n", vol);
hr = IChannelAudioVolume_SetChannelVolume(acv, fmt->nChannels, -1.f, NULL);
ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_SetChannelVolume(acv, 0, -1.f, NULL);
ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 2.f, NULL);
ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 0.2f, NULL);
ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelVolume(acv, 0, &vol);
ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
ok(fabsf(vol - 0.2f) < 0.05f, "Channel volume wasn't 0.2: %f\n", vol);
hr = IChannelAudioVolume_GetAllVolumes(acv, 0, NULL);
ok(hr == NULL_PTR_ERR, "GetAllVolumes gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels, NULL);
ok(hr == NULL_PTR_ERR, "GetAllVolumes gave wrong error: %08x\n", hr);
vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
ok(vols != NULL, "HeapAlloc failed\n");
hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels - 1, vols);
ok(hr == E_INVALIDARG, "GetAllVolumes gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels, vols);
ok(hr == S_OK, "GetAllVolumes failed: %08x\n", hr);
ok(fabsf(vols[0] - 0.2f) < 0.05f, "Channel 0 volume wasn't 0.2: %f\n", vol);
for(i = 1; i < fmt->nChannels; ++i)
ok(vols[i] == 1.f, "Channel %d volume is not 1: %f\n", i, vols[i]);
hr = IChannelAudioVolume_SetAllVolumes(acv, 0, NULL, NULL);
ok(hr == NULL_PTR_ERR, "SetAllVolumes gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels, NULL, NULL);
ok(hr == NULL_PTR_ERR, "SetAllVolumes gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels - 1, vols, NULL);
ok(hr == E_INVALIDARG, "SetAllVolumes gave wrong error: %08x\n", hr);
hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels, vols, NULL);
ok(hr == S_OK, "SetAllVolumes failed: %08x\n", hr);
hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 1.0f, NULL);
ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
HeapFree(GetProcessHeap(), 0, vols);
IChannelAudioVolume_Release(acv);
IAudioClient_Release(ac);
CoTaskMemFree(fmt);
}
static void test_audioclient(void)
{
IAudioClient *ac;
IUnknown *unk;
HRESULT hr;
ULONG ref;
WAVEFORMATEX *pwfx, *pwfx2;
REFERENCE_TIME t1, t2;
HANDLE handle;
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;
handle = CreateEventW(NULL, FALSE, FALSE, NULL);
hr = IAudioClient_QueryInterface(ac, &IID_IUnknown, NULL);
ok(hr == E_POINTER, "QueryInterface(NULL) returned %08x\n", hr);
unk = (void*)(LONG_PTR)0x12345678;
hr = IAudioClient_QueryInterface(ac, &IID_NULL, (void**)&unk);
ok(hr == E_NOINTERFACE, "QueryInterface(IID_NULL) returned %08x\n", hr);
ok(!unk, "QueryInterface(IID_NULL) returned non-null pointer %p\n", unk);
hr = IAudioClient_QueryInterface(ac, &IID_IUnknown, (void**)&unk);
ok(hr == S_OK, "QueryInterface(IID_IUnknown) returned %08x\n", hr);
if (unk)
{
ref = IUnknown_Release(unk);
ok(ref == 1, "Released count is %u\n", ref);
}
hr = IAudioClient_QueryInterface(ac, &IID_IAudioClient, (void**)&unk);
ok(hr == S_OK, "QueryInterface(IID_IAudioClient) returned %08x\n", hr);
if (unk)
{
ref = IUnknown_Release(unk);
ok(ref == 1, "Released count is %u\n", ref);
}
hr = IAudioClient_GetDevicePeriod(ac, NULL, NULL);
ok(hr == E_POINTER, "Invalid GetDevicePeriod call returns %08x\n", hr);
hr = IAudioClient_GetDevicePeriod(ac, &t1, NULL);
ok(hr == S_OK, "Valid GetDevicePeriod call returns %08x\n", hr);
hr = IAudioClient_GetDevicePeriod(ac, NULL, &t2);
ok(hr == S_OK, "Valid GetDevicePeriod call returns %08x\n", hr);
hr = IAudioClient_GetDevicePeriod(ac, &t1, &t2);
ok(hr == S_OK, "Valid GetDevicePeriod call returns %08x\n", hr);
trace("Returned periods: %u.%05u ms %u.%05u ms\n",
(UINT)(t1/10000), (UINT)(t1 % 10000),
(UINT)(t2/10000), (UINT)(t2 % 10000));
hr = IAudioClient_GetMixFormat(ac, NULL);
ok(hr == E_POINTER, "GetMixFormat returns %08x\n", hr);
hr = IAudioClient_GetMixFormat(ac, &pwfx);
ok(hr == S_OK, "Valid GetMixFormat returns %08x\n", hr);
if (hr == S_OK)
{
trace("pwfx: %p\n", pwfx);
trace("Tag: %04x\n", pwfx->wFormatTag);
trace("bits: %u\n", pwfx->wBitsPerSample);
trace("chan: %u\n", pwfx->nChannels);
trace("rate: %u\n", pwfx->nSamplesPerSec);
trace("align: %u\n", pwfx->nBlockAlign);
trace("extra: %u\n", pwfx->cbSize);
ok(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE, "wFormatTag is %x\n", pwfx->wFormatTag);
if (pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
{
WAVEFORMATEXTENSIBLE *pwfxe = (void*)pwfx;
trace("Res: %u\n", pwfxe->Samples.wReserved);
trace("Mask: %x\n", pwfxe->dwChannelMask);
trace("Alg: %s\n",
IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)?"PCM":
(IsEqualGUID(&pwfxe->SubFormat,
&KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)?"FLOAT":"Other"));
}
hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, pwfx, &pwfx2);
ok(hr == S_OK, "Valid IsFormatSupported(Shared) call returns %08x\n", hr);
ok(pwfx2 == NULL, "pwfx2 is non-null\n");
CoTaskMemFree(pwfx2);
hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, NULL, NULL);
ok(hr == E_POINTER, "IsFormatSupported(NULL) call returns %08x\n", hr);
hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, pwfx, NULL);
ok(hr == E_POINTER, "IsFormatSupported(Shared,NULL) call returns %08x\n", hr);
hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_EXCLUSIVE, pwfx, NULL);
ok(hr == S_OK || hr == AUDCLNT_E_UNSUPPORTED_FORMAT, "IsFormatSupported(Exclusive) call returns %08x\n", hr);
hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_EXCLUSIVE, pwfx, &pwfx2);
ok(hr == S_OK || hr == AUDCLNT_E_UNSUPPORTED_FORMAT, "IsFormatSupported(Exclusive) call returns %08x\n", hr);
ok(pwfx2 == NULL, "pwfx2 non-null on exclusive IsFormatSupported\n");
hr = IAudioClient_IsFormatSupported(ac, 0xffffffff, pwfx, NULL);
ok(hr == E_INVALIDARG ||
hr == AUDCLNT_E_UNSUPPORTED_FORMAT,
"IsFormatSupported(0xffffffff) call returns %08x\n", hr);
}
test_uninitialized(ac);
hr = IAudioClient_Initialize(ac, 3, 0, 5000000, 0, pwfx, NULL);
ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Initialize with invalid sharemode returns %08x\n", hr);
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0xffffffff, 5000000, 0, pwfx, NULL);
ok(hr == E_INVALIDARG, "Initialize with invalid flags returns %08x\n", hr);
/* It seems that if length > 2s or periodicity != 0 the length is ignored and call succeeds
* Since we can only initialize successfully once, skip those tests.
*/
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, NULL, NULL);
ok(hr == E_POINTER, "Initialize with null format returns %08x\n", hr);
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, pwfx, NULL);
ok(hr == S_OK, "Valid Initialize returns %08x\n", hr);
if (hr != S_OK)
{
skip("Cannot initialize %08x, remainder of tests is useless\n", hr);
CoTaskMemFree(pwfx);
return;
}
hr = IAudioClient_GetStreamLatency(ac, NULL);
ok(hr == E_POINTER, "GetStreamLatency(NULL) call returns %08x\n", hr);
hr = IAudioClient_GetStreamLatency(ac, &t1);
ok(hr == S_OK, "Valid GetStreamLatency call returns %08x\n", hr);
trace("Returned latency: %u.%05u ms\n",
(UINT)(t1/10000), (UINT)(t1 % 10000));
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, pwfx, NULL);
ok(hr == AUDCLNT_E_ALREADY_INITIALIZED, "Calling Initialize twice returns %08x\n", hr);
hr = IAudioClient_SetEventHandle(ac, NULL);
ok(hr == E_INVALIDARG, "SetEventHandle(NULL) returns %08x\n", hr);
hr = IAudioClient_SetEventHandle(ac, handle);
ok(hr == AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED ||
broken(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME)) ||
broken(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) /* Some 2k8 */ ||
broken(hr == HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME)) /* Some Vista */
, "SetEventHandle returns %08x\n", hr);
hr = IAudioClient_Reset(ac);
ok(hr == S_OK, "Reset on a resetted stream returns %08x\n", hr);
hr = IAudioClient_Stop(ac);
ok(hr == S_FALSE, "Stop on a stopped stream returns %08x\n", hr);
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start on a stopped stream returns %08x\n", hr);
IAudioClient_Release(ac);
CloseHandle(handle);
CoTaskMemFree(pwfx);
}
static void test_session(void)
{
IAudioClient *ses1_ac1, *ses1_ac2, *cap_ac = NULL;
IAudioSessionControl2 *ses1_ctl, *ses1_ctl2, *cap_ctl;
IMMDevice *cap_dev;
GUID ses1_guid;
AudioSessionState state;
WAVEFORMATEX *pwfx;
ULONG ref;
HRESULT hr;
hr = CoCreateGuid(&ses1_guid);
ok(hr == S_OK, "CoCreateGuid failed: %08x\n", hr);
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ses1_ac1);
ok(hr == S_OK, "Activation failed with %08x\n", hr);
hr = IAudioClient_GetMixFormat(ses1_ac1, &pwfx);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(ses1_ac1, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, pwfx, &ses1_guid);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ses1_ac2);
ok(hr == S_OK, "Activation failed with %08x\n", hr);
hr = IAudioClient_Initialize(ses1_ac2, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, pwfx, &ses1_guid);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eCapture,
eMultimedia, &cap_dev);
if(hr == S_OK){
WAVEFORMATEX *cap_pwfx;
hr = IMMDevice_Activate(cap_dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&cap_ac);
ok(hr == S_OK, "Activate failed: %08x\n", hr);
hr = IAudioClient_GetMixFormat(cap_ac, &cap_pwfx);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(cap_ac, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, cap_pwfx, &ses1_guid);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(cap_ac, &IID_IAudioSessionControl, (void**)&cap_ctl);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
IMMDevice_Release(cap_dev);
CoTaskMemFree(cap_pwfx);
}else
skip("No capture device available; skipping capture device in render session tests\n");
hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl2, (void**)&ses1_ctl);
ok(hr == E_NOINTERFACE, "GetService gave wrong error: %08x\n", hr);
hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
ok(ses1_ctl == ses1_ctl2, "Got different controls: %p %p\n", ses1_ctl, ses1_ctl2);
ref = IAudioSessionControl_Release(ses1_ctl2);
ok(ref != 0, "AudioSessionControl was destroyed\n");
hr = IAudioClient_GetService(ses1_ac2, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, NULL);
ok(hr == NULL_PTR_ERR, "GetState gave wrong error: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
if(cap_ac){
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
}
hr = IAudioClient_Start(ses1_ac1);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
if(cap_ac){
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
}
hr = IAudioClient_Stop(ses1_ac1);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
if(cap_ac){
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioClient_Start(cap_ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
hr = IAudioClient_Stop(cap_ac);
ok(hr == S_OK, "Stop failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
ref = IAudioSessionControl_Release(cap_ctl);
ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
ref = IAudioClient_Release(cap_ac);
ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
}
ref = IAudioSessionControl_Release(ses1_ctl);
ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
ref = IAudioClient_Release(ses1_ac1);
ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
ref = IAudioClient_Release(ses1_ac2);
ok(ref == 1, "AudioClient had wrong refcount: %u\n", ref);
/* we've released all of our IAudioClient references, so check GetState */
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
ref = IAudioSessionControl_Release(ses1_ctl2);
ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
CoTaskMemFree(pwfx);
}
static void test_clock(void)
{
HRESULT hr;
IAudioClient *ac;
IAudioClock *acl;
IAudioRenderClient *arc;
UINT64 freq, pos, pcpos, last;
BYTE *data;
WAVEFORMATEX *pwfx;
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);
if(hr != S_OK)
return;
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, pwfx, NULL);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(ac, &IID_IAudioClock, (void**)&acl);
ok(hr == S_OK, "GetService(IAudioClock) failed: %08x\n", hr);
hr = IAudioClock_GetFrequency(acl, &freq);
ok(hr == S_OK, "GetFrequency failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, NULL, NULL);
ok(hr == E_POINTER, "GetPosition wrong error: %08x\n", hr);
pcpos = 0;
hr = IAudioClock_GetPosition(acl, &pos, &pcpos);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos == 0, "GetPosition returned non-zero pos before being started\n");
ok(pcpos != 0, "GetPosition returned zero pcpos\n");
last = pos;
hr = IAudioClient_GetService(ac, &IID_IAudioRenderClient, (void**)&arc);
ok(hr == S_OK, "GetService(IAudioRenderClient) failed: %08x\n", hr);
hr = IAudioRenderClient_GetBuffer(arc, pwfx->nSamplesPerSec / 2., &data);
ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
hr = IAudioRenderClient_ReleaseBuffer(arc, pwfx->nSamplesPerSec / 2., AUDCLNT_BUFFERFLAGS_SILENT);
ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos == 0, "GetPosition returned non-zero pos before being started\n");
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
Sleep(100);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos > 0, "Position should have been further along...\n");
last = pos;
hr = IAudioClient_Stop(ac);
ok(hr == S_OK, "Stop failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos >= last, "Position should have been further along...\n");
last = pos;
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
Sleep(100);
hr = IAudioClient_Stop(ac);
ok(hr == S_OK, "Stop failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos >= last, "Position should have been further along...\n");
last = pos;
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos == last, "Position should have been further along...\n");
hr = IAudioClient_Reset(ac);
ok(hr == S_OK, "Reset failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos == 0, "GetPosition returned non-zero pos after Reset\n");
last = pos;
hr = IAudioRenderClient_GetBuffer(arc, pwfx->nSamplesPerSec / 2., &data);
ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
hr = IAudioRenderClient_ReleaseBuffer(arc, pwfx->nSamplesPerSec / 2., AUDCLNT_BUFFERFLAGS_SILENT);
ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos == 0, "GetPosition returned non-zero pos after Reset\n");
last = pos;
hr = IAudioClient_Start(ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
Sleep(100);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos > last, "Position should have been further along...\n");
hr = IAudioClient_Stop(ac);
ok(hr == S_OK, "Stop failed: %08x\n", hr);
hr = IAudioClock_GetPosition(acl, &pos, NULL);
ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
ok(pos >= last, "Position should have been further along...\n");
IAudioClock_Release(acl);
IAudioClient_Release(ac);
}
static void test_padding(void)
{
HRESULT hr;
IAudioClient *ac;
IAudioRenderClient *arc;
WAVEFORMATEX *pwfx;
REFERENCE_TIME minp, defp;
BYTE *buf;
UINT32 psize, pad, written;
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);
if(hr != S_OK)
return;
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, pwfx, NULL);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetDevicePeriod(ac, &defp, &minp);
ok(hr == S_OK, "GetDevicePeriod failed: %08x\n", hr);
ok(defp != 0, "Default period is 0\n");
ok(minp != 0, "Minimum period is 0\n");
ok(minp <= defp, "Mininum period is greater than default period\n");
hr = IAudioClient_GetService(ac, &IID_IAudioRenderClient, (void**)&arc);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
psize = (defp / 10000000.) * pwfx->nSamplesPerSec * pwfx->nBlockAlign;
written = 0;
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
hr = IAudioRenderClient_GetBuffer(arc, psize, &buf);
ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
ok(buf != NULL, "NULL buffer returned\n");
hr = IAudioRenderClient_ReleaseBuffer(arc, psize,
AUDCLNT_BUFFERFLAGS_SILENT);
ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
written += psize;
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
psize = (minp / 10000000.) * pwfx->nSamplesPerSec * pwfx->nBlockAlign;
hr = IAudioRenderClient_GetBuffer(arc, psize, &buf);
ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
ok(buf != NULL, "NULL buffer returned\n");
hr = IAudioRenderClient_ReleaseBuffer(arc, psize,
AUDCLNT_BUFFERFLAGS_SILENT);
ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
written += psize;
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
/* overfull buffer. requested 1/2s buffer size, so try
* to get a 1/2s buffer, which should fail */
psize = pwfx->nSamplesPerSec / 2.;
hr = IAudioRenderClient_GetBuffer(arc, psize, &buf);
ok(hr == AUDCLNT_E_BUFFER_TOO_LARGE, "GetBuffer gave wrong error: %08x\n", hr);
hr = IAudioRenderClient_ReleaseBuffer(arc, psize, 0);
ok(hr == AUDCLNT_E_OUT_OF_ORDER, "ReleaseBuffer gave wrong error: %08x\n", hr);
hr = IAudioClient_GetCurrentPadding(ac, &pad);
ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
CoTaskMemFree(pwfx);
IAudioRenderClient_Release(arc);
IAudioClient_Release(ac);
}
static HRESULT DoReset(ALCdevice *device)
{
MMDevApiData *data = device->ExtraData;
WAVEFORMATEXTENSIBLE OutputType;
WAVEFORMATEX *wfx = NULL;
REFERENCE_TIME min_per, buf_time;
UINT32 buffer_len, min_len;
HRESULT hr;
hr = IAudioClient_GetMixFormat(data->client, &wfx);
if(FAILED(hr))
{
ERR("Failed to get mix format: 0x%08lx\n", hr);
return hr;
}
if(!MakeExtensible(&OutputType, wfx))
{
CoTaskMemFree(wfx);
return E_FAIL;
}
CoTaskMemFree(wfx);
wfx = NULL;
buf_time = ((REFERENCE_TIME)device->UpdateSize*device->NumUpdates*10000000 +
device->Frequency-1) / device->Frequency;
if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
device->Frequency = OutputType.Format.nSamplesPerSec;
if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
{
if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
device->FmtChans = DevFmtMono;
else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
device->FmtChans = DevFmtStereo;
else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
device->FmtChans = DevFmtQuad;
else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
device->FmtChans = DevFmtX51;
else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE)
device->FmtChans = DevFmtX51Side;
else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
device->FmtChans = DevFmtX61;
else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
device->FmtChans = DevFmtX71;
else
ERR("Unhandled channel config: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
}
switch(device->FmtChans)
{
case DevFmtMono:
OutputType.Format.nChannels = 1;
OutputType.dwChannelMask = MONO;
break;
case DevFmtStereo:
OutputType.Format.nChannels = 2;
OutputType.dwChannelMask = STEREO;
break;
case DevFmtQuad:
OutputType.Format.nChannels = 4;
OutputType.dwChannelMask = QUAD;
break;
case DevFmtX51:
OutputType.Format.nChannels = 6;
OutputType.dwChannelMask = X5DOT1;
break;
case DevFmtX51Side:
OutputType.Format.nChannels = 6;
OutputType.dwChannelMask = X5DOT1SIDE;
break;
case DevFmtX61:
OutputType.Format.nChannels = 7;
OutputType.dwChannelMask = X6DOT1;
break;
case DevFmtX71:
OutputType.Format.nChannels = 8;
OutputType.dwChannelMask = X7DOT1;
break;
}
switch(device->FmtType)
{
case DevFmtByte:
device->FmtType = DevFmtUByte;
/* fall-through */
case DevFmtUByte:
OutputType.Format.wBitsPerSample = 8;
OutputType.Samples.wValidBitsPerSample = 8;
OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
break;
case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
OutputType.Format.wBitsPerSample = 16;
OutputType.Samples.wValidBitsPerSample = 16;
OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
break;
case DevFmtUInt:
device->FmtType = DevFmtInt;
/* fall-through */
case DevFmtInt:
OutputType.Format.wBitsPerSample = 32;
OutputType.Samples.wValidBitsPerSample = 32;
OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
break;
case DevFmtFloat:
OutputType.Format.wBitsPerSample = 32;
OutputType.Samples.wValidBitsPerSample = 32;
OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
break;
}
OutputType.Format.nSamplesPerSec = device->Frequency;
OutputType.Format.nBlockAlign = OutputType.Format.nChannels *
OutputType.Format.wBitsPerSample / 8;
OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
OutputType.Format.nBlockAlign;
hr = IAudioClient_IsFormatSupported(data->client, AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
if(FAILED(hr))
{
ERR("Failed to check format support: 0x%08lx\n", hr);
hr = IAudioClient_GetMixFormat(data->client, &wfx);
}
if(FAILED(hr))
{
ERR("Failed to find a supported format: 0x%08lx\n", hr);
return hr;
}
if(wfx != NULL)
{
if(!MakeExtensible(&OutputType, wfx))
{
CoTaskMemFree(wfx);
return E_FAIL;
}
CoTaskMemFree(wfx);
wfx = NULL;
device->Frequency = OutputType.Format.nSamplesPerSec;
if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
device->FmtChans = DevFmtMono;
else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
device->FmtChans = DevFmtStereo;
else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
device->FmtChans = DevFmtQuad;
else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
device->FmtChans = DevFmtX51;
else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE)
device->FmtChans = DevFmtX51Side;
else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
device->FmtChans = DevFmtX61;
else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
device->FmtChans = DevFmtX71;
else
{
ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
device->FmtChans = DevFmtStereo;
OutputType.Format.nChannels = 2;
OutputType.dwChannelMask = STEREO;
}
if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
{
if(OutputType.Format.wBitsPerSample == 8)
device->FmtType = DevFmtUByte;
else if(OutputType.Format.wBitsPerSample == 16)
device->FmtType = DevFmtShort;
else if(OutputType.Format.wBitsPerSample == 32)
device->FmtType = DevFmtInt;
else
{
device->FmtType = DevFmtShort;
OutputType.Format.wBitsPerSample = 16;
}
}
else if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
{
device->FmtType = DevFmtFloat;
OutputType.Format.wBitsPerSample = 32;
}
else
{
ERR("Unhandled format sub-type\n");
device->FmtType = DevFmtShort;
OutputType.Format.wBitsPerSample = 16;
OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
}
OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
}
SetDefaultWFXChannelOrder(device);
hr = IAudioClient_Initialize(data->client, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
buf_time, 0, &OutputType.Format, NULL);
if(FAILED(hr))
{
ERR("Failed to initialize audio client: 0x%08lx\n", hr);
return hr;
}
hr = IAudioClient_GetDevicePeriod(data->client, &min_per, NULL);
if(SUCCEEDED(hr))
{
min_len = (UINT32)((min_per*device->Frequency + 10000000-1) / 10000000);
/* Find the nearest multiple of the period size to the update size */
if(min_len < device->UpdateSize)
min_len *= (device->UpdateSize + min_len/2)/min_len;
hr = IAudioClient_GetBufferSize(data->client, &buffer_len);
}
if(FAILED(hr))
{
ERR("Failed to get audio buffer info: 0x%08lx\n", hr);
return hr;
}
device->UpdateSize = min_len;
device->NumUpdates = buffer_len / device->UpdateSize;
if(device->NumUpdates <= 1)
{
ERR("Audio client returned buffer_len < period*2; expect break up\n");
device->NumUpdates = 2;
device->UpdateSize = buffer_len / device->NumUpdates;
}
return hr;
}
static void test_volume_dependence(void)
{
IAudioClient *ac, *ac2;
ISimpleAudioVolume *sav;
IChannelAudioVolume *cav;
IAudioStreamVolume *asv;
WAVEFORMATEX *fmt;
HRESULT hr;
float vol;
GUID session;
UINT32 nch;
hr = CoCreateGuid(&session);
ok(hr == S_OK, "CoCreateGuid failed: %08x\n", hr);
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ac);
ok(hr == S_OK, "Activation failed with %08x\n", hr);
hr = IAudioClient_GetMixFormat(ac, &fmt);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
ok(hr == S_OK, "GetService (SimpleAudioVolume) failed: %08x\n", hr);
hr = IAudioClient_GetService(ac, &IID_IChannelAudioVolume, (void**)&cav);
ok(hr == S_OK, "GetService (ChannelAudioVolme) failed: %08x\n", hr);
hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
ok(hr == S_OK, "GetService (AudioStreamVolume) failed: %08x\n", hr);
hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 0.2f);
ok(hr == S_OK, "ASV_SetChannelVolume failed: %08x\n", hr);
hr = IChannelAudioVolume_SetChannelVolume(cav, 0, 0.4f, NULL);
ok(hr == S_OK, "CAV_SetChannelVolume failed: %08x\n", hr);
hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.6f, NULL);
ok(hr == S_OK, "SAV_SetMasterVolume failed: %08x\n", hr);
hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
ok(hr == S_OK, "ASV_GetChannelVolume failed: %08x\n", hr);
ok(fabsf(vol - 0.2) < 0.05f, "ASV_GetChannelVolume gave wrong volume: %f\n", vol);
hr = IChannelAudioVolume_GetChannelVolume(cav, 0, &vol);
ok(hr == S_OK, "CAV_GetChannelVolume failed: %08x\n", hr);
ok(fabsf(vol - 0.4) < 0.05f, "CAV_GetChannelVolume gave wrong volume: %f\n", vol);
hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
ok(hr == S_OK, "SAV_GetMasterVolume failed: %08x\n", hr);
ok(fabsf(vol - 0.6) < 0.05f, "SAV_GetMasterVolume gave wrong volume: %f\n", vol);
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ac2);
if(SUCCEEDED(hr)){
IChannelAudioVolume *cav2;
IAudioStreamVolume *asv2;
hr = IAudioClient_Initialize(ac2, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(ac2, &IID_IChannelAudioVolume, (void**)&cav2);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IAudioClient_GetService(ac2, &IID_IAudioStreamVolume, (void**)&asv2);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IChannelAudioVolume_GetChannelVolume(cav2, 0, &vol);
ok(hr == S_OK, "CAV_GetChannelVolume failed: %08x\n", hr);
ok(fabsf(vol - 0.4) < 0.05f, "CAV_GetChannelVolume gave wrong volume: %f\n", vol);
hr = IAudioStreamVolume_GetChannelVolume(asv2, 0, &vol);
ok(hr == S_OK, "ASV_GetChannelVolume failed: %08x\n", hr);
ok(vol == 1.f, "ASV_GetChannelVolume gave wrong volume: %f\n", vol);
hr = IChannelAudioVolume_GetChannelCount(cav2, &nch);
ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
ok(nch == fmt->nChannels, "Got wrong channel count, expected %u: %u\n", fmt->nChannels, nch);
hr = IAudioStreamVolume_GetChannelCount(asv2, &nch);
ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
ok(nch == fmt->nChannels, "Got wrong channel count, expected %u: %u\n", fmt->nChannels, nch);
IAudioStreamVolume_Release(asv2);
IChannelAudioVolume_Release(cav2);
IAudioClient_Release(ac2);
}else
skip("Unable to open the same device twice. Skipping session volume control tests\n");
hr = IChannelAudioVolume_SetChannelVolume(cav, 0, 1.f, NULL);
ok(hr == S_OK, "CAV_SetChannelVolume failed: %08x\n", hr);
hr = ISimpleAudioVolume_SetMasterVolume(sav, 1.f, NULL);
ok(hr == S_OK, "SAV_SetMasterVolume failed: %08x\n", hr);
CoTaskMemFree(fmt);
ISimpleAudioVolume_Release(sav);
IChannelAudioVolume_Release(cav);
IAudioStreamVolume_Release(asv);
IAudioClient_Release(ac);
}
static void test_simplevolume(void)
{
IAudioClient *ac;
ISimpleAudioVolume *sav;
WAVEFORMATEX *fmt;
HRESULT hr;
float vol;
BOOL mute;
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, &fmt);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, NULL);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = ISimpleAudioVolume_GetMasterVolume(sav, NULL);
ok(hr == NULL_PTR_ERR, "GetMasterVolume gave wrong error: %08x\n", hr);
hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
ok(vol == 1.f, "Master volume wasn't 1: %f\n", vol);
hr = ISimpleAudioVolume_SetMasterVolume(sav, -1.f, NULL);
ok(hr == E_INVALIDARG, "SetMasterVolume gave wrong error: %08x\n", hr);
hr = ISimpleAudioVolume_SetMasterVolume(sav, 2.f, NULL);
ok(hr == E_INVALIDARG, "SetMasterVolume gave wrong error: %08x\n", hr);
hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.2f, NULL);
ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
ok(fabsf(vol - 0.2f) < 0.05f, "Master volume wasn't 0.2: %f\n", vol);
hr = ISimpleAudioVolume_GetMute(sav, NULL);
ok(hr == NULL_PTR_ERR, "GetMute gave wrong error: %08x\n", hr);
mute = TRUE;
hr = ISimpleAudioVolume_GetMute(sav, &mute);
todo_wine ok(hr == S_OK, "GetMute failed: %08x\n", hr);
todo_wine ok(mute == FALSE, "Session is already muted\n");
hr = ISimpleAudioVolume_SetMute(sav, TRUE, NULL);
todo_wine ok(hr == S_OK, "SetMute failed: %08x\n", hr);
mute = FALSE;
hr = ISimpleAudioVolume_GetMute(sav, &mute);
todo_wine ok(hr == S_OK, "GetMute failed: %08x\n", hr);
todo_wine ok(mute == TRUE, "Session should have been muted\n");
hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
ok(fabsf(vol - 0.2f) < 0.05f, "Master volume wasn't 0.2: %f\n", vol);
hr = ISimpleAudioVolume_SetMasterVolume(sav, 1.f, NULL);
ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
mute = FALSE;
hr = ISimpleAudioVolume_GetMute(sav, &mute);
todo_wine ok(hr == S_OK, "GetMute failed: %08x\n", hr);
todo_wine ok(mute == TRUE, "Session should have been muted\n");
hr = ISimpleAudioVolume_SetMute(sav, FALSE, NULL);
todo_wine ok(hr == S_OK, "SetMute failed: %08x\n", hr);
ISimpleAudioVolume_Release(sav);
IAudioClient_Release(ac);
CoTaskMemFree(fmt);
}
HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave)
{
HRESULT hres;
REFERENCE_TIME period;
UINT32 frames;
DWORD period_ms;
IAudioClient *client = NULL;
IAudioRenderClient *render = NULL;
IAudioStreamVolume *volume = NULL;
DWORD fraglen;
WAVEFORMATEX *wfx = NULL;
DWORD oldspeakerconfig = device->speaker_config;
TRACE("(%p, %d)\n", device, forcewave);
hres = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,
CLSCTX_INPROC_SERVER, NULL, (void **)&client);
if(FAILED(hres)){
WARN("Activate failed: %08x\n", hres);
return hres;
}
hres = DSOUND_WaveFormat(device, client, forcewave, &wfx);
if (FAILED(hres)) {
IAudioClient_Release(client);
return hres;
}
hres = IAudioClient_Initialize(client,
AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST |
AUDCLNT_STREAMFLAGS_EVENTCALLBACK, 800000, 0, wfx, NULL);
if(FAILED(hres)){
IAudioClient_Release(client);
ERR("Initialize failed: %08x\n", hres);
return hres;
}
IAudioClient_SetEventHandle(client, device->sleepev);
hres = IAudioClient_GetService(client, &IID_IAudioRenderClient, (void**)&render);
if(FAILED(hres))
goto err_service;
hres = IAudioClient_GetService(client, &IID_IAudioStreamVolume, (void**)&volume);
if(FAILED(hres))
goto err_service;
/* Now kick off the timer so the event fires periodically */
hres = IAudioClient_Start(client);
if (FAILED(hres)) {
WARN("Start failed with %08x\n", hres);
goto err;
}
hres = IAudioClient_GetStreamLatency(client, &period);
if (FAILED(hres)) {
WARN("GetStreamLatency failed with %08x\n", hres);
goto err;
}
hres = IAudioClient_GetBufferSize(client, &frames);
if (FAILED(hres)) {
WARN("GetBufferSize failed with %08x\n", hres);
goto err;
}
period_ms = (period + 9999) / 10000;
fraglen = MulDiv(wfx->nSamplesPerSec, period, 10000000) * wfx->nBlockAlign;
TRACE("period %u ms fraglen %u buflen %u\n", period_ms, fraglen, frames * wfx->nBlockAlign);
hres = DSOUND_PrimaryOpen(device, wfx, frames, forcewave);
if(FAILED(hres))
goto err;
DSOUND_ReleaseDevice(device);
device->client = client;
device->render = render;
device->volume = volume;
device->fraglen = fraglen;
device->aclen = frames * wfx->nBlockAlign;
if (period_ms < 3)
device->sleeptime = 5;
else
device->sleeptime = period_ms * 5 / 2;
return S_OK;
err_service:
WARN("GetService failed: %08x\n", hres);
err:
device->speaker_config = oldspeakerconfig;
DSOUND_ParseSpeakerConfig(device);
if (volume)
IAudioStreamVolume_Release(volume);
if (render)
IAudioRenderClient_Release(render);
IAudioClient_Release(client);
HeapFree(GetProcessHeap(), 0, wfx);
return hres;
}
static gboolean
gst_wasapi_sink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec)
{
GstWasapiSink *self = GST_WASAPI_SINK (asink);
gboolean res = FALSE;
HRESULT hr;
REFERENCE_TIME latency_rt, def_period, min_period;
WAVEFORMATEXTENSIBLE format;
IAudioRenderClient *render_client = NULL;
hr = IAudioClient_GetDevicePeriod (self->client, &def_period, &min_period);
if (hr != S_OK) {
GST_ERROR_OBJECT (self, "IAudioClient::GetDevicePeriod () failed");
goto beach;
}
gst_wasapi_util_audio_info_to_waveformatex (&spec->info, &format);
self->info = spec->info;
hr = IAudioClient_Initialize (self->client, AUDCLNT_SHAREMODE_SHARED,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
spec->buffer_time / 100, 0, (WAVEFORMATEX *) & format, NULL);
if (hr != S_OK) {
GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NULL),
("IAudioClient::Initialize () failed: %s",
gst_wasapi_util_hresult_to_string (hr)));
goto beach;
}
hr = IAudioClient_GetStreamLatency (self->client, &latency_rt);
if (hr != S_OK) {
GST_ERROR_OBJECT (self, "IAudioClient::GetStreamLatency () failed");
goto beach;
}
GST_INFO_OBJECT (self, "default period: %d (%d ms), "
"minimum period: %d (%d ms), "
"latency: %d (%d ms)",
(guint32) def_period, (guint32) def_period / 10000,
(guint32) min_period, (guint32) min_period / 10000,
(guint32) latency_rt, (guint32) latency_rt / 10000);
/* FIXME: What to do with the latency? */
hr = IAudioClient_SetEventHandle (self->client, self->event_handle);
if (hr != S_OK) {
GST_ERROR_OBJECT (self, "IAudioClient::SetEventHandle () failed");
goto beach;
}
if (!gst_wasapi_util_get_render_client (GST_ELEMENT (self), self->client,
&render_client)) {
goto beach;
}
hr = IAudioClient_Start (self->client);
if (hr != S_OK) {
GST_ERROR_OBJECT (self, "IAudioClient::Start failed");
goto beach;
}
self->render_client = render_client;
render_client = NULL;
res = TRUE;
beach:
if (render_client != NULL)
IUnknown_Release (render_client);
return res;
}
HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave)
{
UINT prebuf_frames;
REFERENCE_TIME prebuf_rt;
WAVEFORMATEX *wfx = NULL;
HRESULT hres;
REFERENCE_TIME period;
DWORD period_ms;
TRACE("(%p, %d)\n", device, forcewave);
if(device->client){
IAudioClient_Release(device->client);
device->client = NULL;
}
if(device->render){
IAudioRenderClient_Release(device->render);
device->render = NULL;
}
if(device->clock){
IAudioClock_Release(device->clock);
device->clock = NULL;
}
if(device->volume){
IAudioStreamVolume_Release(device->volume);
device->volume = NULL;
}
hres = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,
CLSCTX_INPROC_SERVER, NULL, (void **)&device->client);
if(FAILED(hres)) {
WARN("Activate failed: %08x\n", hres);
return hres;
}
hres = DSOUND_WaveFormat(device, device->client, forcewave, &wfx);
if (FAILED(hres)) {
IAudioClient_Release(device->client);
device->client = NULL;
return hres;
}
HeapFree(GetProcessHeap(), 0, device->pwfx);
device->pwfx = wfx;
prebuf_frames = device->prebuf * DSOUND_fraglen(device) / device->pwfx->nBlockAlign;
prebuf_rt = (10000000 * (UINT64)prebuf_frames) / device->pwfx->nSamplesPerSec;
hres = IAudioClient_Initialize(device->client,
AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST |
AUDCLNT_STREAMFLAGS_EVENTCALLBACK, prebuf_rt, 0, device->pwfx, NULL);
if(FAILED(hres)){
IAudioClient_Release(device->client);
device->client = NULL;
WARN("Initialize failed: %08x\n", hres);
return hres;
}
IAudioClient_SetEventHandle(device->client, device->sleepev);
hres = IAudioClient_GetService(device->client, &IID_IAudioRenderClient,
(void**)&device->render);
if(FAILED(hres)){
IAudioClient_Release(device->client);
device->client = NULL;
WARN("GetService failed: %08x\n", hres);
return hres;
}
hres = IAudioClient_GetService(device->client, &IID_IAudioClock,
(void**)&device->clock);
if(FAILED(hres)){
IAudioClient_Release(device->client);
IAudioRenderClient_Release(device->render);
device->client = NULL;
device->render = NULL;
WARN("GetService failed: %08x\n", hres);
return hres;
}
hres = IAudioClient_GetService(device->client, &IID_IAudioStreamVolume,
(void**)&device->volume);
if(FAILED(hres)){
IAudioClient_Release(device->client);
IAudioRenderClient_Release(device->render);
IAudioClock_Release(device->clock);
device->client = NULL;
device->render = NULL;
device->clock = NULL;
WARN("GetService failed: %08x\n", hres);
return hres;
}
/* Now kick off the timer so the event fires periodically */
hres = IAudioClient_Start(device->client);
if (FAILED(hres))
WARN("starting failed with %08x\n", hres);
hres = IAudioClient_GetStreamLatency(device->client, &period);
if (FAILED(hres)) {
WARN("GetStreamLatency failed with %08x\n", hres);
period_ms = 10;
} else
period_ms = (period + 9999) / 10000;
TRACE("period %u ms fraglen %u prebuf %u\n", period_ms, device->fraglen, device->prebuf);
if (period_ms < 3)
device->sleeptime = 5;
else
device->sleeptime = period_ms * 5 / 2;
return S_OK;
}
HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave)
{
UINT prebuf_frames;
REFERENCE_TIME prebuf_rt;
HRESULT hres;
TRACE("(%p, %d)\n", device, forcewave);
if(device->client){
IAudioClient_Release(device->client);
device->client = NULL;
}
if(device->render){
IAudioRenderClient_Release(device->render);
device->render = NULL;
}
if(device->clock){
IAudioClock_Release(device->clock);
device->clock = NULL;
}
if(device->volume){
IAudioStreamVolume_Release(device->volume);
device->volume = NULL;
}
hres = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,
CLSCTX_INPROC_SERVER, NULL, (void **)&device->client);
if(FAILED(hres)){
WARN("Activate failed: %08x\n", hres);
return hres;
}
prebuf_frames = device->prebuf * DSOUND_fraglen(device->pwfx->nSamplesPerSec, device->pwfx->nBlockAlign) / device->pwfx->nBlockAlign;
prebuf_rt = (10000000 * (UINT64)prebuf_frames) / device->pwfx->nSamplesPerSec;
hres = IAudioClient_Initialize(device->client,
AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST,
prebuf_rt, 0, device->pwfx, NULL);
if(FAILED(hres)){
IAudioClient_Release(device->client);
device->client = NULL;
WARN("Initialize failed: %08x\n", hres);
return hres;
}
hres = IAudioClient_GetService(device->client, &IID_IAudioRenderClient,
(void**)&device->render);
if(FAILED(hres)){
IAudioClient_Release(device->client);
device->client = NULL;
WARN("GetService failed: %08x\n", hres);
return hres;
}
hres = IAudioClient_GetService(device->client, &IID_IAudioClock,
(void**)&device->clock);
if(FAILED(hres)){
IAudioClient_Release(device->client);
IAudioRenderClient_Release(device->render);
device->client = NULL;
device->render = NULL;
WARN("GetService failed: %08x\n", hres);
return hres;
}
hres = IAudioClient_GetService(device->client, &IID_IAudioStreamVolume,
(void**)&device->volume);
if(FAILED(hres)){
IAudioClient_Release(device->client);
IAudioRenderClient_Release(device->render);
IAudioClock_Release(device->clock);
device->client = NULL;
device->render = NULL;
device->clock = NULL;
WARN("GetService failed: %08x\n", hres);
return hres;
}
return S_OK;
}
static void test_references(void)
{
IAudioClient *ac;
IAudioRenderClient *rc;
ISimpleAudioVolume *sav;
IAudioStreamVolume *asv;
IAudioClock *acl;
WAVEFORMATEX *pwfx;
HRESULT hr;
ULONG ref;
/* IAudioRenderClient */
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);
if(hr != S_OK)
return;
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_IAudioRenderClient, (void**)&rc);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
IAudioRenderClient_AddRef(rc);
ref = IAudioRenderClient_Release(rc);
ok(ref != 0, "RenderClient_Release gave wrong refcount: %u\n", ref);
ref = IAudioClient_Release(ac);
ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
ref = IAudioRenderClient_Release(rc);
ok(ref == 0, "RenderClient_Release gave wrong refcount: %u\n", ref);
/* ISimpleAudioVolume */
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_ISimpleAudioVolume, (void**)&sav);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
ISimpleAudioVolume_AddRef(sav);
ref = ISimpleAudioVolume_Release(sav);
ok(ref != 0, "SimpleAudioVolume_Release gave wrong refcount: %u\n", ref);
ref = IAudioClient_Release(ac);
ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
ref = ISimpleAudioVolume_Release(sav);
ok(ref == 0, "SimpleAudioVolume_Release gave wrong refcount: %u\n", ref);
/* IAudioClock */
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_IAudioClock, (void**)&acl);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
IAudioClock_AddRef(acl);
ref = IAudioClock_Release(acl);
ok(ref != 0, "AudioClock_Release gave wrong refcount: %u\n", ref);
ref = IAudioClient_Release(ac);
ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
ref = IAudioClock_Release(acl);
ok(ref == 0, "AudioClock_Release gave wrong refcount: %u\n", ref);
/* IAudioStreamVolume */
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);
hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
IAudioStreamVolume_AddRef(asv);
ref = IAudioStreamVolume_Release(asv);
ok(ref != 0, "AudioStreamVolume_Release gave wrong refcount: %u\n", ref);
ref = IAudioClient_Release(ac);
ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
ref = IAudioStreamVolume_Release(asv);
ok(ref == 0, "AudioStreamVolume_Release gave wrong refcount: %u\n", ref);
}
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;
}
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);
}
