2 * Copyright 2010 Maarten Lankhorst for CodeWeavers
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 /* This test is for audio playback specific mechanisms
22 * - IAudioClient with eRender and IAudioRenderClient
28 #include "wine/test.h"
38 #include "mmdeviceapi.h"
40 #include "audioclient.h"
41 #include "audiopolicy.h"
43 static const unsigned int win_formats
[][4] = {
44 { 8000, 8, 1}, { 8000, 8, 2}, { 8000, 16, 1}, { 8000, 16, 2},
45 {11025, 8, 1}, {11025, 8, 2}, {11025, 16, 1}, {11025, 16, 2},
46 {12000, 8, 1}, {12000, 8, 2}, {12000, 16, 1}, {12000, 16, 2},
47 {16000, 8, 1}, {16000, 8, 2}, {16000, 16, 1}, {16000, 16, 2},
48 {22050, 8, 1}, {22050, 8, 2}, {22050, 16, 1}, {22050, 16, 2},
49 {44100, 8, 1}, {44100, 8, 2}, {44100, 16, 1}, {44100, 16, 2},
50 {48000, 8, 1}, {48000, 8, 2}, {48000, 16, 1}, {48000, 16, 2},
51 {96000, 8, 1}, {96000, 8, 2}, {96000, 16, 1}, {96000, 16, 2}
53 #define NB_WIN_FORMATS (sizeof(win_formats)/sizeof(*win_formats))
55 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
57 static IMMDeviceEnumerator
*mme
= NULL
;
58 static IMMDevice
*dev
= NULL
;
59 static HRESULT hexcl
= S_OK
; /* or AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED */
61 static const LARGE_INTEGER ullZero
;
63 #define PI 3.14159265358979323846L
64 static DWORD
wave_generate_tone(PWAVEFORMATEX pwfx
, BYTE
* data
, UINT32 frames
)
66 static double phase
= 0.; /* normalized to unit, not 2*PI */
67 PWAVEFORMATEXTENSIBLE wfxe
= (PWAVEFORMATEXTENSIBLE
)pwfx
;
71 if(!winetest_interactive
)
72 return AUDCLNT_BUFFERFLAGS_SILENT
;
73 if(wfxe
->Format
.wBitsPerSample
!= ((wfxe
->Format
.wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
74 IsEqualGUID(&wfxe
->SubFormat
, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
)) ? 8 * sizeof(float) : 16))
75 return AUDCLNT_BUFFERFLAGS_SILENT
;
77 for(delta
= phase
, cn
= 0; cn
< wfxe
->Format
.nChannels
;
78 delta
+= .5/wfxe
->Format
.nChannels
, cn
++){
79 for(i
= 0; i
< frames
; i
++){
80 y
= sin(2*PI
*(440.* i
/ wfxe
->Format
.nSamplesPerSec
+ delta
));
81 /* assume alignment is granted */
82 if(wfxe
->Format
.wBitsPerSample
== 16)
83 ((short*)data
)[cn
+i
*wfxe
->Format
.nChannels
] = y
* 32767.9;
85 ((float*)data
)[cn
+i
*wfxe
->Format
.nChannels
] = y
;
88 phase
+= 440.* frames
/ wfxe
->Format
.nSamplesPerSec
;
89 phase
-= floor(phase
);
93 static void test_uninitialized(IAudioClient
*ac
)
99 HANDLE handle
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
102 hr
= IAudioClient_GetBufferSize(ac
, &num
);
103 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized GetBufferSize call returns %08x\n", hr
);
105 hr
= IAudioClient_GetStreamLatency(ac
, &t1
);
106 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized GetStreamLatency call returns %08x\n", hr
);
108 hr
= IAudioClient_GetCurrentPadding(ac
, &num
);
109 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized GetCurrentPadding call returns %08x\n", hr
);
111 hr
= IAudioClient_Start(ac
);
112 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized Start call returns %08x\n", hr
);
114 hr
= IAudioClient_Stop(ac
);
115 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized Stop call returns %08x\n", hr
);
117 hr
= IAudioClient_Reset(ac
);
118 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized Reset call returns %08x\n", hr
);
120 hr
= IAudioClient_SetEventHandle(ac
, handle
);
121 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized SetEventHandle call returns %08x\n", hr
);
123 hr
= IAudioClient_GetService(ac
, &IID_IAudioStreamVolume
, (void**)&unk
);
124 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Uninitialized GetService call returns %08x\n", hr
);
129 static void test_audioclient(void)
135 WAVEFORMATEX
*pwfx
, *pwfx2
;
136 REFERENCE_TIME t1
, t2
;
139 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
141 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
145 handle
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
147 hr
= IAudioClient_QueryInterface(ac
, &IID_IUnknown
, NULL
);
148 ok(hr
== E_POINTER
, "QueryInterface(NULL) returned %08x\n", hr
);
150 unk
= (void*)(LONG_PTR
)0x12345678;
151 hr
= IAudioClient_QueryInterface(ac
, &IID_NULL
, (void**)&unk
);
152 ok(hr
== E_NOINTERFACE
, "QueryInterface(IID_NULL) returned %08x\n", hr
);
153 ok(!unk
, "QueryInterface(IID_NULL) returned non-null pointer %p\n", unk
);
155 hr
= IAudioClient_QueryInterface(ac
, &IID_IUnknown
, (void**)&unk
);
156 ok(hr
== S_OK
, "QueryInterface(IID_IUnknown) returned %08x\n", hr
);
159 ref
= IUnknown_Release(unk
);
160 ok(ref
== 1, "Released count is %u\n", ref
);
163 hr
= IAudioClient_QueryInterface(ac
, &IID_IAudioClient
, (void**)&unk
);
164 ok(hr
== S_OK
, "QueryInterface(IID_IAudioClient) returned %08x\n", hr
);
167 ref
= IUnknown_Release(unk
);
168 ok(ref
== 1, "Released count is %u\n", ref
);
171 hr
= IAudioClient_GetDevicePeriod(ac
, NULL
, NULL
);
172 ok(hr
== E_POINTER
, "Invalid GetDevicePeriod call returns %08x\n", hr
);
174 hr
= IAudioClient_GetDevicePeriod(ac
, &t1
, NULL
);
175 ok(hr
== S_OK
, "Valid GetDevicePeriod call returns %08x\n", hr
);
177 hr
= IAudioClient_GetDevicePeriod(ac
, NULL
, &t2
);
178 ok(hr
== S_OK
, "Valid GetDevicePeriod call returns %08x\n", hr
);
180 hr
= IAudioClient_GetDevicePeriod(ac
, &t1
, &t2
);
181 ok(hr
== S_OK
, "Valid GetDevicePeriod call returns %08x\n", hr
);
182 trace("Returned periods: %u.%04u ms %u.%04u ms\n",
183 (UINT
)(t1
/10000), (UINT
)(t1
% 10000),
184 (UINT
)(t2
/10000), (UINT
)(t2
% 10000));
186 hr
= IAudioClient_GetMixFormat(ac
, NULL
);
187 ok(hr
== E_POINTER
, "GetMixFormat returns %08x\n", hr
);
189 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
190 ok(hr
== S_OK
, "Valid GetMixFormat returns %08x\n", hr
);
194 trace("pwfx: %p\n", pwfx
);
195 trace("Tag: %04x\n", pwfx
->wFormatTag
);
196 trace("bits: %u\n", pwfx
->wBitsPerSample
);
197 trace("chan: %u\n", pwfx
->nChannels
);
198 trace("rate: %u\n", pwfx
->nSamplesPerSec
);
199 trace("align: %u\n", pwfx
->nBlockAlign
);
200 trace("extra: %u\n", pwfx
->cbSize
);
201 ok(pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
, "wFormatTag is %x\n", pwfx
->wFormatTag
);
202 if (pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
204 WAVEFORMATEXTENSIBLE
*pwfxe
= (void*)pwfx
;
205 trace("Res: %u\n", pwfxe
->Samples
.wReserved
);
206 trace("Mask: %x\n", pwfxe
->dwChannelMask
);
208 IsEqualGUID(&pwfxe
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
)?"PCM":
209 (IsEqualGUID(&pwfxe
->SubFormat
,
210 &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
)?"FLOAT":"Other"));
213 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
214 ok(hr
== S_OK
, "Valid IsFormatSupported(Shared) call returns %08x\n", hr
);
215 ok(pwfx2
== NULL
, "pwfx2 is non-null\n");
216 CoTaskMemFree(pwfx2
);
218 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, NULL
, NULL
);
219 ok(hr
== E_POINTER
, "IsFormatSupported(NULL) call returns %08x\n", hr
);
221 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, NULL
);
222 ok(hr
== E_POINTER
, "IsFormatSupported(Shared,NULL) call returns %08x\n", hr
);
224 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
225 ok(hr
== S_OK
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
226 "IsFormatSupported(Exclusive) call returns %08x\n", hr
);
229 pwfx2
= (WAVEFORMATEX
*)0xDEADF00D;
230 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, &pwfx2
);
231 ok(hr
== hexcl
, "IsFormatSupported(Exclusive) call returns %08x\n", hr
);
232 ok(pwfx2
== NULL
, "pwfx2 non-null on exclusive IsFormatSupported\n");
234 if (hexcl
!= AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
)
237 hr
= IAudioClient_IsFormatSupported(ac
, 0xffffffff, pwfx
, NULL
);
238 ok(hr
== E_INVALIDARG
/*w32*/ ||
239 broken(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
/*w64 response from exclusive mode driver */),
240 "IsFormatSupported(0xffffffff) call returns %08x\n", hr
);
243 test_uninitialized(ac
);
245 hr
= IAudioClient_Initialize(ac
, 3, 0, 5000000, 0, pwfx
, NULL
);
246 ok(hr
== AUDCLNT_E_NOT_INITIALIZED
, "Initialize with invalid sharemode returns %08x\n", hr
);
248 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0xffffffff, 5000000, 0, pwfx
, NULL
);
249 ok(hr
== E_INVALIDARG
||
250 hr
== AUDCLNT_E_INVALID_STREAM_FLAG
, "Initialize with invalid flags returns %08x\n", hr
);
252 /* A period != 0 is ignored and the call succeeds.
253 * Since we can only initialize successfully once, skip those tests.
255 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000, 0, NULL
, NULL
);
256 ok(hr
== E_POINTER
, "Initialize with null format returns %08x\n", hr
);
258 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 0, 0, pwfx
, NULL
);
259 ok(hr
== S_OK
, "Initialize with 0 buffer size returns %08x\n", hr
);
263 hr
= IAudioClient_GetBufferSize(ac
, &num
);
264 ok(hr
== S_OK
, "GetBufferSize from duration 0 returns %08x\n", hr
);
266 trace("Initialize(duration=0) GetBufferSize is %u\n", num
);
269 IAudioClient_Release(ac
);
271 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
273 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
275 if(pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
){
276 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)pwfx
;
277 WAVEFORMATEX
*fmt2
= NULL
;
279 ok(fmtex
->dwChannelMask
!= 0, "Got empty dwChannelMask\n");
281 fmtex
->dwChannelMask
= 0xffff;
283 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000, 0, pwfx
, NULL
);
284 ok(hr
== S_OK
, "Initialize(dwChannelMask = 0xffff) returns %08x\n", hr
);
286 IAudioClient_Release(ac
);
288 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
290 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
292 fmtex
->dwChannelMask
= 0;
294 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &fmt2
);
295 ok(hr
== S_OK
|| broken(hr
== S_FALSE
/* w7 Realtek HDA */),
296 "IsFormatSupported(dwChannelMask = 0) call returns %08x\n", hr
);
297 ok(fmtex
->dwChannelMask
== 0, "Passed format was modified\n");
301 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000, 0, pwfx
, NULL
);
302 ok(hr
== S_OK
, "Initialize(dwChannelMask = 0) returns %08x\n", hr
);
304 IAudioClient_Release(ac
);
306 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
308 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
312 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
313 ok(hr
== S_OK
, "Valid GetMixFormat returns %08x\n", hr
);
315 skip("Skipping dwChannelMask tests\n");
317 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000, 0, pwfx
, NULL
);
318 ok(hr
== S_OK
, "Valid Initialize returns %08x\n", hr
);
321 IAudioClient_Release(ac
);
326 hr
= IAudioClient_GetStreamLatency(ac
, NULL
);
327 ok(hr
== E_POINTER
, "GetStreamLatency(NULL) call returns %08x\n", hr
);
329 hr
= IAudioClient_GetStreamLatency(ac
, &t2
);
330 ok(hr
== S_OK
, "Valid GetStreamLatency call returns %08x\n", hr
);
331 trace("Returned latency: %u.%04u ms\n",
332 (UINT
)(t2
/10000), (UINT
)(t2
% 10000));
333 ok(t2
>= t1
|| broken(t2
>= t1
/2 && pwfx
->nSamplesPerSec
> 48000),
334 "Latency < default period, delta %ldus\n", (long)((t2
-t1
)/10));
335 /* Native appears to add the engine period to the HW latency in shared mode */
337 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000, 0, pwfx
, NULL
);
338 ok(hr
== AUDCLNT_E_ALREADY_INITIALIZED
, "Calling Initialize twice returns %08x\n", hr
);
340 hr
= IAudioClient_SetEventHandle(ac
, NULL
);
341 ok(hr
== E_INVALIDARG
, "SetEventHandle(NULL) returns %08x\n", hr
);
343 hr
= IAudioClient_SetEventHandle(ac
, handle
);
344 ok(hr
== AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED
||
345 broken(hr
== HRESULT_FROM_WIN32(ERROR_INVALID_NAME
)) ||
346 broken(hr
== HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
)) /* Some 2k8 */ ||
347 broken(hr
== HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME
)) /* Some Vista */
348 , "SetEventHandle returns %08x\n", hr
);
350 hr
= IAudioClient_Reset(ac
);
351 ok(hr
== S_OK
, "Reset on an initialized stream returns %08x\n", hr
);
353 hr
= IAudioClient_Reset(ac
);
354 ok(hr
== S_OK
, "Reset on a resetted stream returns %08x\n", hr
);
356 hr
= IAudioClient_Stop(ac
);
357 ok(hr
== S_FALSE
, "Stop on a stopped stream returns %08x\n", hr
);
359 hr
= IAudioClient_Start(ac
);
360 ok(hr
== S_OK
, "Start on a stopped stream returns %08x\n", hr
);
362 hr
= IAudioClient_Start(ac
);
363 ok(hr
== AUDCLNT_E_NOT_STOPPED
, "Start twice returns %08x\n", hr
);
365 IAudioClient_Release(ac
);
371 static void test_formats(AUDCLNT_SHAREMODE mode
)
375 WAVEFORMATEX fmt
, *pwfx
, *pwfx2
;
378 fmt
.wFormatTag
= WAVE_FORMAT_PCM
;
381 for(i
= 0; i
< NB_WIN_FORMATS
; i
++) {
382 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
384 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
388 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
389 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
391 fmt
.nSamplesPerSec
= win_formats
[i
][0];
392 fmt
.wBitsPerSample
= win_formats
[i
][1];
393 fmt
.nChannels
= win_formats
[i
][2];
394 fmt
.nBlockAlign
= fmt
.nChannels
* fmt
.wBitsPerSample
/ 8;
395 fmt
.nAvgBytesPerSec
= fmt
.nBlockAlign
* fmt
.nSamplesPerSec
;
397 pwfx2
= (WAVEFORMATEX
*)0xDEADF00D;
398 hr
= IAudioClient_IsFormatSupported(ac
, mode
, &fmt
, &pwfx2
);
400 /* Only shared mode suggests something ... GetMixFormat! */
401 ok(hr
== S_OK
|| (mode
== AUDCLNT_SHAREMODE_SHARED
402 ? hr
== S_FALSE
|| broken(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
&&
403 /* 5:1 card exception when asked for 1 channel at mixer rate */
404 pwfx
->nChannels
> 2 && fmt
.nSamplesPerSec
== pwfx
->nSamplesPerSec
)
405 : (hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== hexcl
)),
406 "IsFormatSupported(%d, %ux%2ux%u) returns %08x\n", mode
,
407 fmt
.nSamplesPerSec
, fmt
.wBitsPerSample
, fmt
.nChannels
, hr
);
409 trace("IsSupported(%s, %ux%2ux%u)\n",
410 mode
== AUDCLNT_SHAREMODE_SHARED
? "shared " : "exclus.",
411 fmt
.nSamplesPerSec
, fmt
.wBitsPerSample
, fmt
.nChannels
);
413 /* Change GetMixFormat wBitsPerSample only => S_OK */
414 if (mode
== AUDCLNT_SHAREMODE_SHARED
415 && fmt
.nSamplesPerSec
== pwfx
->nSamplesPerSec
416 && fmt
.nChannels
== pwfx
->nChannels
)
417 ok(hr
== S_OK
, "Varying BitsPerSample %u\n", fmt
.wBitsPerSample
);
419 ok((hr
== S_FALSE
)^(pwfx2
== NULL
), "hr %x<->suggest %p\n", hr
, pwfx2
);
420 if (pwfx2
== (WAVEFORMATEX
*)0xDEADF00D)
421 pwfx2
= NULL
; /* broken in Wine < 1.3.28 */
423 ok(pwfx2
->nSamplesPerSec
== pwfx
->nSamplesPerSec
&&
424 pwfx2
->nChannels
== pwfx
->nChannels
&&
425 pwfx2
->wBitsPerSample
== pwfx
->wBitsPerSample
,
426 "Suggestion %ux%2ux%u differs from GetMixFormat\n",
427 pwfx2
->nSamplesPerSec
, pwfx2
->wBitsPerSample
, pwfx2
->nChannels
);
430 /* Vista returns E_INVALIDARG upon AUDCLNT_STREAMFLAGS_RATEADJUST */
431 hr
= IAudioClient_Initialize(ac
, mode
, 0, 5000000, 0, &fmt
, NULL
);
432 if ((hrs
== S_OK
) ^ (hr
== S_OK
))
433 trace("Initialize (%s, %ux%2ux%u) returns %08x unlike IsFormatSupported\n",
434 mode
== AUDCLNT_SHAREMODE_SHARED
? "shared " : "exclus.",
435 fmt
.nSamplesPerSec
, fmt
.wBitsPerSample
, fmt
.nChannels
, hr
);
436 if (mode
== AUDCLNT_SHAREMODE_SHARED
)
437 ok(hrs
== S_OK
? hr
== S_OK
: hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
,
438 "Initialize(shared, %ux%2ux%u) returns %08x\n",
439 fmt
.nSamplesPerSec
, fmt
.wBitsPerSample
, fmt
.nChannels
, hr
);
440 else if (hrs
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
)
441 /* Unsupported format implies "create failed" and shadows "not allowed" */
442 ok(hrs
== hexcl
&& (hr
== AUDCLNT_E_ENDPOINT_CREATE_FAILED
|| hr
== hrs
),
443 "Initialize(noexcl., %ux%2ux%u) returns %08x(%08x)\n",
444 fmt
.nSamplesPerSec
, fmt
.wBitsPerSample
, fmt
.nChannels
, hr
, hrs
);
446 /* On testbot 48000x16x1 claims support, but does not Initialize.
447 * Some cards Initialize 44100|48000x16x1 yet claim no support;
448 * F. Gouget's w7 bots do that for 12000|96000x8|16x1|2 */
449 ok(hrs
== S_OK
? hr
== S_OK
|| broken(hr
== AUDCLNT_E_ENDPOINT_CREATE_FAILED
)
450 : hr
== AUDCLNT_E_ENDPOINT_CREATE_FAILED
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
||
452 ((fmt
.nChannels
== 1 && fmt
.wBitsPerSample
== 16) ||
453 (fmt
.nSamplesPerSec
== 12000 || fmt
.nSamplesPerSec
== 96000))),
454 "Initialize(exclus., %ux%2ux%u) returns %08x\n",
455 fmt
.nSamplesPerSec
, fmt
.wBitsPerSample
, fmt
.nChannels
, hr
);
457 /* Bug in native (Vista/w2k8/w7): after Initialize failed, better
458 * Release this ac and Activate a new one.
459 * A second call (with a known working format) would yield
460 * ALREADY_INITIALIZED in shared mode yet be unusable, and in exclusive
461 * mode some entity keeps a lock on the device, causing DEVICE_IN_USE to
462 * all subsequent calls until the audio engine service is restarted. */
464 CoTaskMemFree(pwfx2
);
466 IAudioClient_Release(ac
);
470 static void test_formats2(void)
474 WAVEFORMATEX
*pwfx
, *pwfx2
;
475 WAVEFORMATEXTENSIBLE
*pwfe
, wfe
, *pwfe2
;
477 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
480 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
484 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
485 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
489 ok(pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
, "Invalid wFormatTag\n");
490 if (pwfx
->wFormatTag
!= WAVE_FORMAT_EXTENSIBLE
) {
495 pwfe
= (WAVEFORMATEXTENSIBLE
*)pwfx
;
496 ok(pwfe
->Samples
.wValidBitsPerSample
, "wValidBitsPerSample should be non-zero\n");
498 if (pwfx
->nChannels
> 2) {
499 trace("Limiting channels to 2\n");
501 pwfx
->nBlockAlign
= pwfx
->wBitsPerSample
/ 8 * pwfx
->nChannels
;
502 pwfx
->nAvgBytesPerSec
= pwfx
->nBlockAlign
* pwfx
->nSamplesPerSec
;
503 pwfe
->dwChannelMask
= SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
;
507 pwfx
->nAvgBytesPerSec
= pwfx
->nBlockAlign
= 0;
509 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
510 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
511 "Exclusive IsFormatSupported with nAvgBytesPerSec=0 and nBlockAlign=0 returned %08x\n", hr
);
514 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
515 ok((hr
== E_INVALIDARG
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && !pwfx2
,
516 "Shared IsFormatSupported with nAvgBytesPerSec=0 and nBlockAlign=0 returned %08x %p\n", hr
, pwfx2
);
517 CoTaskMemFree(pwfx2
);
519 pwfx
->wFormatTag
= WAVE_FORMAT_PCM
;
521 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
522 ok((hr
== S_OK
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && !pwfx2
,
523 "Shared IsFormatSupported with nAvgBytesPerSec=0 and nBlockAlign=0 returned %08x %p\n", hr
, pwfx2
);
524 CoTaskMemFree(pwfx2
);
527 pwfe
->dwChannelMask
= 0;
528 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
529 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
530 "Exclusive IsFormatSupported with dwChannelMask=0 returned %08x\n", hr
);
533 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
535 "Shared IsFormatSupported with dwChannelMask=0 returned %08x\n", hr
);
536 CoTaskMemFree(pwfx2
);
539 pwfe
->dwChannelMask
= 0x3ffff;
540 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
541 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
542 "Exclusive IsFormatSupported with dwChannelMask=0x3ffff returned %08x\n", hr
);
545 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
546 ok(hr
== S_OK
&& !pwfx2
,
547 "Shared IsFormatSupported with dwChannelMask=0x3ffff returned %08x %p\n", hr
, pwfx2
);
548 CoTaskMemFree(pwfx2
);
551 pwfe
->dwChannelMask
= 0x40000000;
552 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
553 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
554 "Exclusive IsFormatSupported with dwChannelMask=0x40000000 returned %08x\n", hr
);
557 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
558 ok(hr
== S_OK
&& !pwfx2
,
559 "Shared IsFormatSupported with dwChannelMask=0x40000000 returned %08x %p\n", hr
, pwfx2
);
560 CoTaskMemFree(pwfx2
);
562 pwfe
->dwChannelMask
= SPEAKER_ALL
| SPEAKER_RESERVED
;
563 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
564 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
565 "Exclusive IsFormatSupported with dwChannelMask=SPEAKER_ALL | SPEAKER_RESERVED returned %08x\n", hr
);
568 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
569 ok(hr
== S_OK
&& !pwfx2
,
570 "Shared IsFormatSupported with dwChannelMask=SPEAKER_ALL | SPEAKER_RESERVED returned %08x %p\n", hr
, pwfx2
);
571 CoTaskMemFree(pwfx2
);
574 pwfe
->Samples
.wValidBitsPerSample
= 0;
575 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
, pwfx
, NULL
);
576 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
|| hr
== AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
,
577 "Exclusive IsFormatSupported with wValidBitsPerSample=0 returned %08x\n", hr
);
580 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
581 ok((hr
== S_FALSE
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && pwfx2
,
582 "Shared IsFormatSupported with wValidBitsPerSample=0 returned %08x %p\n", hr
, pwfx2
);
584 pwfe2
= (WAVEFORMATEXTENSIBLE
*)pwfx2
;
585 ok(pwfe2
->Samples
.wValidBitsPerSample
== pwfx
->wBitsPerSample
,
586 "Shared IsFormatSupported had wValidBitsPerSample set to %u, not %u\n",
587 pwfe2
->Samples
.wValidBitsPerSample
, pwfx
->wBitsPerSample
);
588 CoTaskMemFree(pwfx2
);
592 pwfe
->Samples
.wValidBitsPerSample
= pwfx
->wBitsPerSample
+ 1;
593 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
594 ok((hr
== E_INVALIDARG
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && !pwfx2
,
595 "Shared IsFormatSupported with wValidBitsPerSample += 1 returned %08x %p\n", hr
, pwfx2
);
598 memset(&pwfe
->SubFormat
, 0xff, 16);
600 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
601 ok(hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
&& !pwfx2
,
602 "Shared IsFormatSupported with SubFormat=-1 returned %08x %p\n", hr
, pwfx2
);
603 CoTaskMemFree(pwfx2
);
607 pwfe
->Samples
.wValidBitsPerSample
= pwfx
->wBitsPerSample
= 256;
608 pwfx
->nBlockAlign
= pwfx
->wBitsPerSample
/ 8 * pwfx
->nChannels
;
609 pwfx
->nAvgBytesPerSec
= pwfx
->nBlockAlign
* pwfx
->nSamplesPerSec
;
610 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
611 ok((hr
== E_INVALIDARG
|| hr
== AUDCLNT_E_UNSUPPORTED_FORMAT
) && !pwfx2
,
612 "Shared IsFormatSupported with wBitsPerSample=256 returned %08x %p\n", hr
, pwfx2
);
613 CoTaskMemFree(pwfx2
);
617 pwfe
->Samples
.wValidBitsPerSample
= pwfx
->wBitsPerSample
- 1;
618 hr
= IAudioClient_IsFormatSupported(ac
, AUDCLNT_SHAREMODE_SHARED
, pwfx
, &pwfx2
);
619 ok(hr
== S_FALSE
&& pwfx2
,
620 "Shared IsFormatSupported with wValidBitsPerSample-=1 returned %08x %p\n", hr
, pwfx2
);
622 pwfe2
= (WAVEFORMATEXTENSIBLE
*)pwfx2
;
623 ok(pwfe2
->Samples
.wValidBitsPerSample
== pwfx
->wBitsPerSample
,
624 "Shared IsFormatSupported had wValidBitsPerSample set to %u, not %u\n",
625 pwfe2
->Samples
.wValidBitsPerSample
, pwfx
->wBitsPerSample
);
626 CoTaskMemFree(pwfx2
);
630 IAudioClient_Release(ac
);
633 static void test_references(void)
636 IAudioRenderClient
*rc
;
637 ISimpleAudioVolume
*sav
;
638 IAudioStreamVolume
*asv
;
644 /* IAudioRenderClient */
645 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
647 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
651 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
652 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
654 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000,
656 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
660 hr
= IAudioClient_GetService(ac
, &IID_IAudioRenderClient
, (void**)&rc
);
661 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
663 IAudioClient_Release(ac
);
667 IAudioRenderClient_AddRef(rc
);
668 ref
= IAudioRenderClient_Release(rc
);
669 ok(ref
!= 0, "RenderClient_Release gave wrong refcount: %u\n", ref
);
671 ref
= IAudioClient_Release(ac
);
672 ok(ref
!= 0, "Client_Release gave wrong refcount: %u\n", ref
);
674 ref
= IAudioRenderClient_Release(rc
);
675 ok(ref
== 0, "RenderClient_Release gave wrong refcount: %u\n", ref
);
677 /* ISimpleAudioVolume */
678 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
680 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
684 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
685 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
687 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000,
689 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
693 hr
= IAudioClient_GetService(ac
, &IID_ISimpleAudioVolume
, (void**)&sav
);
694 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
696 ISimpleAudioVolume_AddRef(sav
);
697 ref
= ISimpleAudioVolume_Release(sav
);
698 ok(ref
!= 0, "SimpleAudioVolume_Release gave wrong refcount: %u\n", ref
);
700 ref
= IAudioClient_Release(ac
);
701 ok(ref
!= 0, "Client_Release gave wrong refcount: %u\n", ref
);
703 ref
= ISimpleAudioVolume_Release(sav
);
704 ok(ref
== 0, "SimpleAudioVolume_Release gave wrong refcount: %u\n", ref
);
707 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
709 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
713 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
714 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
716 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000,
718 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
722 hr
= IAudioClient_GetService(ac
, &IID_IAudioClock
, (void**)&acl
);
723 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
725 IAudioClock_AddRef(acl
);
726 ref
= IAudioClock_Release(acl
);
727 ok(ref
!= 0, "AudioClock_Release gave wrong refcount: %u\n", ref
);
729 ref
= IAudioClient_Release(ac
);
730 ok(ref
!= 0, "Client_Release gave wrong refcount: %u\n", ref
);
732 ref
= IAudioClock_Release(acl
);
733 ok(ref
== 0, "AudioClock_Release gave wrong refcount: %u\n", ref
);
735 /* IAudioStreamVolume */
736 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
738 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
742 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
743 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
745 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000,
747 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
751 hr
= IAudioClient_GetService(ac
, &IID_IAudioStreamVolume
, (void**)&asv
);
752 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
754 IAudioStreamVolume_AddRef(asv
);
755 ref
= IAudioStreamVolume_Release(asv
);
756 ok(ref
!= 0, "AudioStreamVolume_Release gave wrong refcount: %u\n", ref
);
758 ref
= IAudioClient_Release(ac
);
759 ok(ref
!= 0, "Client_Release gave wrong refcount: %u\n", ref
);
761 ref
= IAudioStreamVolume_Release(asv
);
762 ok(ref
== 0, "AudioStreamVolume_Release gave wrong refcount: %u\n", ref
);
765 static void test_event(void)
773 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
775 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
779 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
780 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
782 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
783 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
, 5000000,
785 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
789 event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
790 ok(event
!= NULL
, "CreateEvent failed\n");
792 hr
= IAudioClient_Start(ac
);
793 ok(hr
== AUDCLNT_E_EVENTHANDLE_NOT_SET
, "Start failed: %08x\n", hr
);
795 hr
= IAudioClient_SetEventHandle(ac
, event
);
796 ok(hr
== S_OK
, "SetEventHandle failed: %08x\n", hr
);
798 hr
= IAudioClient_SetEventHandle(ac
, event
);
799 ok(hr
== HRESULT_FROM_WIN32(ERROR_INVALID_NAME
), "SetEventHandle returns %08x\n", hr
);
801 r
= WaitForSingleObject(event
, 40);
802 ok(r
== WAIT_TIMEOUT
, "Wait(event) before Start gave %x\n", r
);
804 hr
= IAudioClient_Start(ac
);
805 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
807 r
= WaitForSingleObject(event
, 20);
808 ok(r
== WAIT_OBJECT_0
, "Wait(event) after Start gave %x\n", r
);
810 hr
= IAudioClient_Stop(ac
);
811 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
813 ok(ResetEvent(event
), "ResetEvent\n");
815 /* Still receiving events! */
816 r
= WaitForSingleObject(event
, 20);
817 ok(r
== WAIT_OBJECT_0
, "Wait(event) after Stop gave %x\n", r
);
819 hr
= IAudioClient_Reset(ac
);
820 ok(hr
== S_OK
, "Reset failed: %08x\n", hr
);
822 ok(ResetEvent(event
), "ResetEvent\n");
824 r
= WaitForSingleObject(event
, 120);
825 ok(r
== WAIT_OBJECT_0
, "Wait(event) after Reset gave %x\n", r
);
827 hr
= IAudioClient_SetEventHandle(ac
, NULL
);
828 ok(hr
== E_INVALIDARG
, "SetEventHandle(NULL) returns %08x\n", hr
);
830 r
= WaitForSingleObject(event
, 70);
831 ok(r
== WAIT_OBJECT_0
, "Wait(NULL event) gave %x\n", r
);
833 /* test releasing a playing stream */
834 hr
= IAudioClient_Start(ac
);
835 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
836 IAudioClient_Release(ac
);
841 static void test_padding(void)
845 IAudioRenderClient
*arc
;
847 REFERENCE_TIME minp
, defp
;
849 UINT32 psize
, pad
, written
, i
;
851 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
853 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
857 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
858 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
862 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
863 0, 5000000, 0, pwfx
, NULL
);
864 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
868 if(pwfx
->wBitsPerSample
== 8)
874 * Default (= shared) device period is 10ms (e.g. 441 frames at 44100),
875 * except when the HW/OS forces a particular alignment,
876 * e.g. 10.1587ms is 28 * 16 = 448 frames at 44100 with HDA.
877 * 441 observed with Vista, 448 with w7 on the same HW! */
878 hr
= IAudioClient_GetDevicePeriod(ac
, &defp
, &minp
);
879 ok(hr
== S_OK
, "GetDevicePeriod failed: %08x\n", hr
);
880 /* some wineXYZ.drv use 20ms, not seen on native */
881 ok(defp
== 100000 || broken(defp
== 101587) || defp
== 200000,
882 "Expected 10ms default period: %u\n", (ULONG
)defp
);
883 ok(minp
!= 0, "Minimum period is 0\n");
884 ok(minp
<= defp
, "Mininum period is greater than default period\n");
886 hr
= IAudioClient_GetService(ac
, &IID_IAudioRenderClient
, (void**)&arc
);
887 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
889 psize
= MulDiv(defp
, pwfx
->nSamplesPerSec
, 10000000) * 10;
892 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
893 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
894 ok(pad
== written
, "GetCurrentPadding returned %u, should be %u\n", pad
, written
);
896 hr
= IAudioRenderClient_GetBuffer(arc
, psize
, &buf
);
897 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
898 ok(buf
!= NULL
, "NULL buffer returned\n");
899 for(i
= 0; i
< psize
* pwfx
->nBlockAlign
; ++i
){
900 if(buf
[i
] != silence
){
901 ok(0, "buffer has data in it already\n");
906 hr
= IAudioRenderClient_GetBuffer(arc
, 0, &buf
);
907 ok(hr
== AUDCLNT_E_OUT_OF_ORDER
, "GetBuffer 0 size failed: %08x\n", hr
);
908 ok(buf
== NULL
, "GetBuffer 0 gave %p\n", buf
);
909 /* MSDN instead documents buf remains untouched */
911 hr
= IAudioClient_Reset(ac
);
912 ok(hr
== AUDCLNT_E_BUFFER_OPERATION_PENDING
, "Reset failed: %08x\n", hr
);
914 hr
= IAudioRenderClient_ReleaseBuffer(arc
, psize
,
915 AUDCLNT_BUFFERFLAGS_SILENT
);
916 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
917 if(hr
== S_OK
) written
+= psize
;
919 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
920 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
921 ok(pad
== written
, "GetCurrentPadding returned %u, should be %u\n", pad
, written
);
923 psize
= MulDiv(minp
, pwfx
->nSamplesPerSec
, 10000000) * 10;
925 hr
= IAudioRenderClient_GetBuffer(arc
, psize
, &buf
);
926 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
927 ok(buf
!= NULL
, "NULL buffer returned\n");
929 hr
= IAudioRenderClient_ReleaseBuffer(arc
, psize
,
930 AUDCLNT_BUFFERFLAGS_SILENT
);
931 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
934 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
935 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
936 ok(pad
== written
, "GetCurrentPadding returned %u, should be %u\n", pad
, written
);
938 /* overfull buffer. requested 1/2s buffer size, so try
939 * to get a 1/2s buffer, which should fail */
940 psize
= pwfx
->nSamplesPerSec
/ 2;
941 buf
= (void*)0xDEADF00D;
942 hr
= IAudioRenderClient_GetBuffer(arc
, psize
, &buf
);
943 ok(hr
== AUDCLNT_E_BUFFER_TOO_LARGE
, "GetBuffer gave wrong error: %08x\n", hr
);
944 ok(buf
== NULL
, "NULL expected %p\n", buf
);
946 hr
= IAudioRenderClient_ReleaseBuffer(arc
, psize
, 0);
947 ok(hr
== AUDCLNT_E_OUT_OF_ORDER
, "ReleaseBuffer gave wrong error: %08x\n", hr
);
949 psize
= MulDiv(minp
, pwfx
->nSamplesPerSec
, 10000000) * 2;
951 hr
= IAudioRenderClient_GetBuffer(arc
, psize
, &buf
);
952 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
953 ok(buf
!= NULL
, "NULL buffer returned\n");
955 hr
= IAudioRenderClient_ReleaseBuffer(arc
, 0, 0);
956 ok(hr
== S_OK
, "ReleaseBuffer 0 gave wrong error: %08x\n", hr
);
958 buf
= (void*)0xDEADF00D;
959 hr
= IAudioRenderClient_GetBuffer(arc
, 0, &buf
);
960 ok(hr
== S_OK
, "GetBuffer 0 size failed: %08x\n", hr
);
961 ok(buf
== NULL
, "GetBuffer 0 gave %p\n", buf
);
962 /* MSDN instead documents buf remains untouched */
964 buf
= (void*)0xDEADF00D;
965 hr
= IAudioRenderClient_GetBuffer(arc
, 0, &buf
);
966 ok(hr
== S_OK
, "GetBuffer 0 size #2 failed: %08x\n", hr
);
967 ok(buf
== NULL
, "GetBuffer 0 #2 gave %p\n", buf
);
969 hr
= IAudioRenderClient_ReleaseBuffer(arc
, psize
, 0);
970 ok(hr
== AUDCLNT_E_OUT_OF_ORDER
, "ReleaseBuffer not size 0 gave %08x\n", hr
);
972 hr
= IAudioRenderClient_GetBuffer(arc
, psize
, &buf
);
973 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
974 ok(buf
!= NULL
, "NULL buffer returned\n");
976 hr
= IAudioRenderClient_ReleaseBuffer(arc
, 0, 0);
977 ok(hr
== S_OK
, "ReleaseBuffer 0 gave wrong error: %08x\n", hr
);
979 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
980 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
981 ok(pad
== written
, "GetCurrentPadding returned %u, should be %u\n", pad
, written
);
983 hr
= IAudioRenderClient_GetBuffer(arc
, psize
, &buf
);
984 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
985 ok(buf
!= NULL
, "NULL buffer returned\n");
987 hr
= IAudioRenderClient_ReleaseBuffer(arc
, psize
+1, AUDCLNT_BUFFERFLAGS_SILENT
);
988 ok(hr
== AUDCLNT_E_INVALID_SIZE
, "ReleaseBuffer too large error: %08x\n", hr
);
989 /* todo_wine means Wine may overwrite memory */
990 if(hr
== S_OK
) written
+= psize
+1;
992 /* Buffer still hold */
993 hr
= IAudioRenderClient_ReleaseBuffer(arc
, psize
/2, AUDCLNT_BUFFERFLAGS_SILENT
);
994 ok(hr
== S_OK
, "ReleaseBuffer after error: %08x\n", hr
);
995 if(hr
== S_OK
) written
+= psize
/2;
997 hr
= IAudioRenderClient_ReleaseBuffer(arc
, 0, 0);
998 ok(hr
== S_OK
, "ReleaseBuffer 0 gave wrong error: %08x\n", hr
);
1000 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1001 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1002 ok(pad
== written
, "GetCurrentPadding returned %u, should be %u\n", pad
, written
);
1004 CoTaskMemFree(pwfx
);
1006 IAudioRenderClient_Release(arc
);
1007 IAudioClient_Release(ac
);
1010 static void test_clock(int share
)
1015 IAudioRenderClient
*arc
;
1016 UINT64 freq
, pos
, pcpos0
, pcpos
, last
;
1017 UINT32 pad
, gbsize
, bufsize
, fragment
, parts
, avail
, slept
= 0, sum
= 0;
1020 LARGE_INTEGER hpctime
, hpctime0
, hpcfreq
;
1021 REFERENCE_TIME minp
, defp
, t1
, t2
;
1022 REFERENCE_TIME duration
= 5000000, period
= 150000;
1025 ok(QueryPerformanceFrequency(&hpcfreq
), "PerfFrequency failed\n");
1027 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1029 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1033 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
1034 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1038 hr
= IAudioClient_GetDevicePeriod(ac
, &defp
, &minp
);
1039 ok(hr
== S_OK
, "GetDevicePeriod failed: %08x\n", hr
);
1040 ok(minp
<= period
, "desired period %u too small for %u\n", (ULONG
)period
, (ULONG
)minp
);
1043 trace("Testing shared mode\n");
1044 /* period is ignored */
1045 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
1046 0, duration
, period
, pwfx
, NULL
);
1049 pwfx
->wFormatTag
= WAVE_FORMAT_PCM
;
1050 pwfx
->nChannels
= 2;
1052 pwfx
->wBitsPerSample
= 16; /* no floating point */
1053 pwfx
->nBlockAlign
= pwfx
->nChannels
* pwfx
->wBitsPerSample
/ 8;
1054 pwfx
->nAvgBytesPerSec
= pwfx
->nSamplesPerSec
* pwfx
->nBlockAlign
;
1055 trace("Testing exclusive mode at %u\n", pwfx
->nSamplesPerSec
);
1057 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_EXCLUSIVE
,
1058 0, duration
, period
, pwfx
, NULL
);
1060 ok(share
? hr
== S_OK
: hr
== hexcl
|| hr
== AUDCLNT_E_DEVICE_IN_USE
, "Initialize failed: %08x\n", hr
);
1062 CoTaskMemFree(pwfx
);
1063 IAudioClient_Release(ac
);
1064 if(hr
== AUDCLNT_E_DEVICE_IN_USE
)
1065 skip("Device in use, no %s access\n", share
? "shared" : "exclusive");
1069 /** GetStreamLatency
1070 * Shared mode: 1x period + a little, but some 192000 devices return 5.3334ms.
1071 * Exclusive mode: testbot returns 2x period + a little, but
1072 * some HDA drivers return 1x period, some + a little. */
1073 hr
= IAudioClient_GetStreamLatency(ac
, &t2
);
1074 ok(hr
== S_OK
, "GetStreamLatency failed: %08x\n", hr
);
1075 trace("Latency: %u.%04u ms\n", (UINT
)(t2
/10000), (UINT
)(t2
% 10000));
1076 ok(t2
>= period
|| broken(t2
>= period
/2 && share
&& pwfx
->nSamplesPerSec
> 48000),
1077 "Latency < default period, delta %ldus\n", (long)((t2
-period
)/10));
1080 * BufferSize must be rounded up, maximum 2s says MSDN.
1081 * Both is wrong. Rounding may lead to size a little smaller than duration;
1082 * duration > 2s is accepted in shared mode.
1083 * Shared mode: round solely w.r.t. mixer rate,
1084 * duration is no multiple of period.
1085 * Exclusive mode: size appears as a multiple of some fragment that
1086 * is either the rounded period or a fixed constant like 1024,
1087 * whatever the driver implements. */
1088 hr
= IAudioClient_GetBufferSize(ac
, &gbsize
);
1089 ok(hr
== S_OK
, "GetBufferSize failed: %08x\n", hr
);
1091 bufsize
= MulDiv(duration
, pwfx
->nSamplesPerSec
, 10000000);
1092 fragment
= MulDiv(period
, pwfx
->nSamplesPerSec
, 10000000);
1093 parts
= MulDiv(bufsize
, 1, fragment
); /* instead of (duration, 1, period) */
1094 trace("BufferSize %u estimated fragment %u x %u = %u\n", gbsize
, fragment
, parts
, fragment
* parts
);
1095 /* fragment size (= period in frames) is rounded up.
1096 * BufferSize must be rounded up, maximum 2s says MSDN
1097 * but it is rounded down modulo fragment ! */
1099 ok(gbsize
== bufsize
,
1100 "BufferSize %u at rate %u\n", gbsize
, pwfx
->nSamplesPerSec
);
1102 ok(gbsize
== parts
* fragment
|| gbsize
== MulDiv(bufsize
, 1, 1024) * 1024,
1103 "BufferSize %u misfits fragment size %u at rate %u\n", gbsize
, fragment
, pwfx
->nSamplesPerSec
);
1105 /* In shared mode, GetCurrentPadding decreases in multiples of
1106 * fragment size (i.e. updated only at period ticks), whereas
1107 * GetPosition appears to be reporting continuous positions.
1108 * In exclusive mode, testbot behaves likewise, but native's Intel
1109 * HDA driver shows no such deltas, GetCurrentPadding closely
1110 * matches GetPosition, as in
1111 * GetCurrentPadding = GetPosition - frames held in mmdevapi */
1113 hr
= IAudioClient_GetService(ac
, &IID_IAudioClock
, (void**)&acl
);
1114 ok(hr
== S_OK
, "GetService(IAudioClock) failed: %08x\n", hr
);
1116 hr
= IAudioClock_GetFrequency(acl
, &freq
);
1117 ok(hr
== S_OK
, "GetFrequency failed: %08x\n", hr
);
1118 trace("Clock Frequency %u\n", (UINT
)freq
);
1120 /* MSDN says it's arbitrary units, but shared mode is unlikely to change */
1122 ok(freq
== pwfx
->nSamplesPerSec
* pwfx
->nBlockAlign
,
1123 "Clock Frequency %u\n", (UINT
)freq
);
1125 ok(freq
== pwfx
->nSamplesPerSec
,
1126 "Clock Frequency %u\n", (UINT
)freq
);
1128 hr
= IAudioClock_GetPosition(acl
, NULL
, NULL
);
1129 ok(hr
== E_POINTER
, "GetPosition wrong error: %08x\n", hr
);
1132 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos0
);
1133 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1134 ok(pos
== 0, "GetPosition returned non-zero pos before being started\n");
1135 ok(pcpos0
!= 0, "GetPosition returned zero pcpos\n");
1137 hr
= IAudioClient_GetService(ac
, &IID_IAudioRenderClient
, (void**)&arc
);
1138 ok(hr
== S_OK
, "GetService(IAudioRenderClient) failed: %08x\n", hr
);
1140 hr
= IAudioRenderClient_GetBuffer(arc
, gbsize
+1, &data
);
1141 ok(hr
== AUDCLNT_E_BUFFER_TOO_LARGE
, "GetBuffer too large failed: %08x\n", hr
);
1145 hr
= IAudioRenderClient_GetBuffer(arc
, avail
, &data
);
1146 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
1147 trace("data at %p\n", data
);
1149 hr
= IAudioRenderClient_ReleaseBuffer(arc
, avail
, winetest_debug
>2 ?
1150 wave_generate_tone(pwfx
, data
, avail
) : AUDCLNT_BUFFERFLAGS_SILENT
);
1151 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
1152 if(hr
== S_OK
) sum
+= avail
;
1154 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1155 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1156 ok(pad
== sum
, "padding %u prior to start\n", pad
);
1158 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1159 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1160 ok(pos
== 0, "GetPosition returned non-zero pos before being started\n");
1162 hr
= IAudioClient_Start(ac
); /* #1 */
1163 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1168 hr
= IAudioClient_GetStreamLatency(ac
, &t1
);
1169 ok(hr
== S_OK
, "GetStreamLatency failed: %08x\n", hr
);
1170 ok(t1
== t2
, "Latency not constant, delta %ld\n", (long)(t1
-t2
));
1172 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1173 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1174 ok(pos
> 0, "Position %u vs. last %u\n", (UINT
)pos
,0);
1175 /* in rare cases is slept*1.1 not enough with dmix */
1176 ok(pos
*1000/freq
<= slept
*1.4, "Position %u too far after playing %ums\n", (UINT
)pos
, slept
);
1179 hr
= IAudioClient_Stop(ac
);
1180 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
1182 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1183 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1184 ok(pos
>= last
, "Position %u vs. last %u\n", (UINT
)pos
,(UINT
)last
);
1186 if(/*share &&*/ winetest_debug
>1)
1187 ok(pos
*1000/freq
<= slept
*1.1, "Position %u too far after stop %ums\n", (UINT
)pos
, slept
);
1189 hr
= IAudioClient_Start(ac
); /* #2 */
1190 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1195 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1196 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1197 trace("padding %u past sleep #2\n", pad
);
1199 /** IAudioClient_Stop
1200 * Exclusive mode: the audio engine appears to drop frames,
1201 * bumping GetPosition to a higher value than time allows, even
1202 * allowing GetPosition > sum Released - GetCurrentPadding (testbot)
1203 * Shared mode: no drop observed (or too small to be visible).
1204 * GetPosition = sum Released - GetCurrentPadding
1205 * Bugs: Some USB headset system drained the whole buffer, leaving
1206 * padding 0 and bumping pos to sum minus 17 frames! */
1208 hr
= IAudioClient_Stop(ac
);
1209 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
1211 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1212 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1214 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1215 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1216 trace("padding %u position %u past stop #2\n", pad
, (UINT
)pos
);
1217 ok(pos
* pwfx
->nSamplesPerSec
<= sum
* freq
, "Position %u > written %u\n", (UINT
)pos
, sum
);
1218 /* Prove that Stop must not drop frames (in shared mode). */
1219 ok(pad
? pos
> last
: pos
>= last
, "Position %u vs. last %u\n", (UINT
)pos
,(UINT
)last
);
1220 if (share
&& pad
> 0 && winetest_debug
>1)
1221 ok(pos
*1000/freq
<= slept
*1.1, "Position %u too far after playing %ums\n", (UINT
)pos
, slept
);
1222 /* in exclusive mode, testbot's w7 machines yield pos > sum-pad */
1223 if(/*share &&*/ winetest_debug
>1)
1224 ok(pos
* pwfx
->nSamplesPerSec
== (sum
-pad
) * freq
,
1225 "Position %u after stop vs. %u padding\n", (UINT
)pos
, pad
);
1230 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1231 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1232 ok(pos
== last
, "Position %u should stop.\n", (UINT
)pos
);
1234 /* Restart from 0 */
1235 hr
= IAudioClient_Reset(ac
);
1236 ok(hr
== S_OK
, "Reset failed: %08x\n", hr
);
1239 hr
= IAudioClient_Reset(ac
);
1240 ok(hr
== S_OK
, "Reset on a resetted stream returns %08x\n", hr
);
1242 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos
);
1243 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1244 ok(pos
== 0, "GetPosition returned non-zero pos after Reset\n");
1245 ok(pcpos
> pcpos0
, "pcpos should increase\n");
1247 avail
= gbsize
; /* implies GetCurrentPadding == 0 */
1248 hr
= IAudioRenderClient_GetBuffer(arc
, avail
, &data
);
1249 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
1250 trace("data at %p\n", data
);
1252 hr
= IAudioRenderClient_ReleaseBuffer(arc
, avail
, winetest_debug
>2 ?
1253 wave_generate_tone(pwfx
, data
, avail
) : AUDCLNT_BUFFERFLAGS_SILENT
);
1254 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
1255 if(hr
== S_OK
) sum
+= avail
;
1257 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1258 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1259 ok(pad
== sum
, "padding %u prior to start\n", pad
);
1261 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1262 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1263 ok(pos
== 0, "GetPosition returned non-zero pos after Reset\n");
1266 hr
= IAudioClient_Start(ac
); /* #3 */
1267 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1272 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1273 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1274 trace("position %u past %ums sleep #3\n", (UINT
)pos
, slept
);
1275 ok(pos
> last
, "Position %u vs. last %u\n", (UINT
)pos
,(UINT
)last
);
1276 ok(pos
* pwfx
->nSamplesPerSec
<= sum
* freq
, "Position %u > written %u\n", (UINT
)pos
, sum
);
1277 if (winetest_debug
>1)
1278 ok(pos
*1000/freq
<= slept
*1.1, "Position %u too far after playing %ums\n", (UINT
)pos
, slept
);
1280 skip("Rerun with WINETEST_DEBUG=2 for GetPosition tests.\n");
1283 hr
= IAudioClient_Reset(ac
);
1284 ok(hr
== AUDCLNT_E_NOT_STOPPED
, "Reset while playing: %08x\n", hr
);
1286 hr
= IAudioClient_Stop(ac
);
1287 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
1289 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1290 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1292 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos
);
1293 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1294 trace("padding %u position %u past stop #3\n", pad
, (UINT
)pos
);
1295 ok(pos
>= last
, "Position %u vs. last %u\n", (UINT
)pos
,(UINT
)last
);
1296 ok(pcpos
> pcpos0
, "pcpos should increase\n");
1297 ok(pos
* pwfx
->nSamplesPerSec
<= sum
* freq
, "Position %u > written %u\n", (UINT
)pos
, sum
);
1298 if (pad
> 0 && winetest_debug
>1)
1299 ok(pos
*1000/freq
<= slept
*1.1, "Position %u too far after stop %ums\n", (UINT
)pos
, slept
);
1300 if(winetest_debug
>1)
1301 ok(pos
* pwfx
->nSamplesPerSec
== (sum
-pad
) * freq
,
1302 "Position %u after stop vs. %u padding\n", (UINT
)pos
, pad
);
1305 /* Begin the big loop */
1306 hr
= IAudioClient_Reset(ac
);
1307 ok(hr
== S_OK
, "Reset failed: %08x\n", hr
);
1308 slept
= last
= sum
= 0;
1311 ok(QueryPerformanceCounter(&hpctime0
), "PerfCounter unavailable\n");
1313 hr
= IAudioClient_Reset(ac
);
1314 ok(hr
== S_OK
, "Reset on a resetted stream returns %08x\n", hr
);
1316 hr
= IAudioClient_Start(ac
);
1317 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1319 avail
= pwfx
->nSamplesPerSec
* 15 / 16 / 2;
1321 hr
= IAudioRenderClient_GetBuffer(arc
, avail
, &data
);
1322 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
1323 trace("data at %p for prefill %u\n", data
, avail
);
1325 if (winetest_debug
>2) {
1326 hr
= IAudioClient_Stop(ac
);
1327 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
1332 hr
= IAudioClient_Reset(ac
);
1333 ok(hr
== AUDCLNT_E_BUFFER_OPERATION_PENDING
, "Reset failed: %08x\n", hr
);
1335 hr
= IAudioClient_Start(ac
);
1336 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1339 /* Despite passed time, data must still point to valid memory... */
1340 hr
= IAudioRenderClient_ReleaseBuffer(arc
, avail
,
1341 wave_generate_tone(pwfx
, data
, avail
));
1342 ok(hr
== S_OK
, "ReleaseBuffer after stop+start failed: %08x\n", hr
);
1343 if(hr
== S_OK
) sum
+= avail
;
1345 /* GetCurrentPadding(GCP) == 0 does not mean an underrun happened, as the
1346 * mixer may still have a little data. We believe an underrun will occur
1347 * when the mixer finds GCP smaller than a period size at the *end* of a
1348 * period cycle, i.e. shortly before calling SetEvent to signal the app
1349 * that it has ~10ms to supply data for the next cycle. IOW, a zero GCP
1350 * with no data written for over a period causes an underrun. */
1354 ok(QueryPerformanceCounter(&hpctime
), "PerfCounter failed\n");
1355 trace("hpctime %u after %ums\n",
1356 (ULONG
)((hpctime
.QuadPart
-hpctime0
.QuadPart
)*1000/hpcfreq
.QuadPart
), slept
);
1358 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos
);
1359 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1360 ok(pos
> last
, "Position %u vs. last %u\n", (UINT
)pos
,(UINT
)last
);
1363 for(i
=0; i
< 9; i
++) {
1367 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos
);
1368 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1370 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1371 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1373 ok(QueryPerformanceCounter(&hpctime
), "PerfCounter failed\n");
1374 trace("hpctime %u pcpos %u\n",
1375 (ULONG
)((hpctime
.QuadPart
-hpctime0
.QuadPart
)*1000/hpcfreq
.QuadPart
),
1376 (ULONG
)((pcpos
-pcpos0
)/10000));
1378 /* Use sum-pad to see whether position is ahead padding or not. */
1379 trace("padding %u position %u/%u slept %ums iteration %d\n", pad
, (UINT
)pos
, sum
-pad
, slept
, i
);
1380 ok(pad
? pos
> last
: pos
>= last
, "No position increase at iteration %d\n", i
);
1381 ok(pos
* pwfx
->nSamplesPerSec
<= sum
* freq
, "Position %u > written %u\n", (UINT
)pos
, sum
);
1382 if (winetest_debug
>1) {
1383 /* Padding does not lag behind by much */
1384 ok(pos
* pwfx
->nSamplesPerSec
<= (sum
-pad
+fragment
) * freq
, "Position %u > written %u\n", (UINT
)pos
, sum
);
1385 ok(pos
*1000/freq
<= slept
*1.1, "Position %u too far after %ums\n", (UINT
)pos
, slept
);
1386 if (pad
) /* not in case of underrun */
1387 ok((pos
-last
)*1000/freq
>= 90 && 110 >= (pos
-last
)*1000/freq
,
1388 "Position delta %ld not regular: %ld ms\n", (long)(pos
-last
), (long)((pos
-last
)*1000/freq
));
1392 hr
= IAudioClient_GetStreamLatency(ac
, &t1
);
1393 ok(hr
== S_OK
, "GetStreamLatency failed: %08x\n", hr
);
1394 ok(t1
== t2
, "Latency not constant, delta %ld\n", (long)(t1
-t2
));
1396 avail
= pwfx
->nSamplesPerSec
* 15 / 16 / 2;
1398 hr
= IAudioRenderClient_GetBuffer(arc
, avail
, &data
);
1399 /* ok(hr == AUDCLNT_E_BUFFER_TOO_LARGE || (hr == S_OK && i==0) without todo_wine */
1400 ok(hr
== S_OK
|| hr
== AUDCLNT_E_BUFFER_TOO_LARGE
,
1401 "GetBuffer large (%u) failed: %08x\n", avail
, hr
);
1402 if(hr
== S_OK
&& i
) ok(FALSE
, "GetBuffer large (%u) at iteration %d\n", avail
, i
);
1403 /* Only the first iteration should allow that large a buffer
1404 * as prefill was drained during the first 350+100ms sleep.
1405 * Afterwards, only 100ms of data should find room per iteration. */
1408 trace("data at %p\n", data
);
1410 avail
= gbsize
- pad
;
1411 hr
= IAudioRenderClient_GetBuffer(arc
, avail
, &data
);
1412 ok(hr
== S_OK
, "GetBuffer small %u failed: %08x\n", avail
, hr
);
1413 trace("data at %p (small %u)\n", data
, avail
);
1415 ok(data
!= NULL
, "NULL buffer returned\n");
1416 if(i
% 3 && !winetest_interactive
) {
1417 memset(data
, 0, avail
* pwfx
->nBlockAlign
);
1418 hr
= IAudioRenderClient_ReleaseBuffer(arc
, avail
, 0);
1420 hr
= IAudioRenderClient_ReleaseBuffer(arc
, avail
,
1421 wave_generate_tone(pwfx
, data
, avail
));
1423 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
1424 if(hr
== S_OK
) sum
+= avail
;
1427 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1428 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1429 trace("position %u\n", (UINT
)pos
);
1431 Sleep(1000); /* 500ms buffer underrun past full buffer */
1433 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
1434 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
1436 hr
= IAudioClock_GetPosition(acl
, &pos
, NULL
);
1437 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
1438 trace("position %u past underrun, %u padding left, %u frames written\n", (UINT
)pos
, pad
, sum
);
1441 /* Following underrun, all samples were played */
1442 ok(pad
== 0, "GetCurrentPadding returned %u, should be 0\n", pad
);
1443 ok(pos
* pwfx
->nSamplesPerSec
== sum
* freq
,
1444 "Position %u at end vs. %u submitted frames\n", (UINT
)pos
, sum
);
1446 /* Vista and w2k8 leave partial fragments behind */
1447 ok(pad
== 0 /* w7, w2k8R2 */||
1448 pos
* pwfx
->nSamplesPerSec
== (sum
-pad
) * freq
, "GetCurrentPadding returned %u, should be 0\n", pad
);
1449 /* expect at most 5 fragments (75ms) away */
1450 ok(pos
* pwfx
->nSamplesPerSec
<= sum
* freq
&&
1451 pos
* pwfx
->nSamplesPerSec
+ 5 * fragment
* freq
>= sum
* freq
,
1452 "Position %u at end vs. %u submitted frames\n", (UINT
)pos
, sum
);
1455 hr
= IAudioClient_GetStreamLatency(ac
, &t1
);
1456 ok(hr
== S_OK
, "GetStreamLatency failed: %08x\n", hr
);
1457 ok(t1
== t2
, "Latency not constant, delta %ld\n", (long)(t1
-t2
));
1459 ok(QueryPerformanceCounter(&hpctime
), "PerfCounter failed\n");
1460 trace("hpctime %u after underrun\n", (ULONG
)((hpctime
.QuadPart
-hpctime0
.QuadPart
)*1000/hpcfreq
.QuadPart
));
1462 hr
= IAudioClient_Stop(ac
);
1463 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
1465 CoTaskMemFree(pwfx
);
1467 IAudioClock_Release(acl
);
1468 IAudioRenderClient_Release(arc
);
1469 IAudioClient_Release(ac
);
1472 static void test_session(void)
1474 IAudioClient
*ses1_ac1
, *ses1_ac2
, *cap_ac
;
1475 IAudioSessionControl2
*ses1_ctl
, *ses1_ctl2
, *cap_ctl
= NULL
;
1478 AudioSessionState state
;
1483 hr
= CoCreateGuid(&ses1_guid
);
1484 ok(hr
== S_OK
, "CoCreateGuid failed: %08x\n", hr
);
1486 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1487 NULL
, (void**)&ses1_ac1
);
1488 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1489 if (FAILED(hr
)) return;
1491 hr
= IAudioClient_GetMixFormat(ses1_ac1
, &pwfx
);
1492 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1494 hr
= IAudioClient_Initialize(ses1_ac1
, AUDCLNT_SHAREMODE_SHARED
,
1495 0, 5000000, 0, pwfx
, &ses1_guid
);
1496 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
1499 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1500 NULL
, (void**)&ses1_ac2
);
1501 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1504 skip("Unable to open the same device twice. Skipping session tests\n");
1506 ref
= IAudioClient_Release(ses1_ac1
);
1507 ok(ref
== 0, "AudioClient wasn't released: %u\n", ref
);
1508 CoTaskMemFree(pwfx
);
1512 hr
= IAudioClient_Initialize(ses1_ac2
, AUDCLNT_SHAREMODE_SHARED
,
1513 0, 5000000, 0, pwfx
, &ses1_guid
);
1514 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
1516 hr
= IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme
, eCapture
,
1517 eMultimedia
, &cap_dev
);
1519 hr
= IMMDevice_Activate(cap_dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1520 NULL
, (void**)&cap_ac
);
1521 ok((hr
== S_OK
)^(cap_ac
== NULL
), "Activate %08x &out pointer\n", hr
);
1522 ok(hr
== S_OK
, "Activate failed: %08x\n", hr
);
1523 IMMDevice_Release(cap_dev
);
1526 WAVEFORMATEX
*cap_pwfx
;
1528 hr
= IAudioClient_GetMixFormat(cap_ac
, &cap_pwfx
);
1529 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1531 hr
= IAudioClient_Initialize(cap_ac
, AUDCLNT_SHAREMODE_SHARED
,
1532 0, 5000000, 0, cap_pwfx
, &ses1_guid
);
1533 ok(hr
== S_OK
, "Initialize failed for capture in rendering session: %08x\n", hr
);
1534 CoTaskMemFree(cap_pwfx
);
1537 hr
= IAudioClient_GetService(cap_ac
, &IID_IAudioSessionControl
, (void**)&cap_ctl
);
1538 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1542 skip("No capture session: %08x; skipping capture device in render session tests\n", hr
);
1544 hr
= IAudioClient_GetService(ses1_ac1
, &IID_IAudioSessionControl2
, (void**)&ses1_ctl
);
1545 ok(hr
== E_NOINTERFACE
, "GetService gave wrong error: %08x\n", hr
);
1547 hr
= IAudioClient_GetService(ses1_ac1
, &IID_IAudioSessionControl
, (void**)&ses1_ctl
);
1548 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1550 hr
= IAudioClient_GetService(ses1_ac1
, &IID_IAudioSessionControl
, (void**)&ses1_ctl2
);
1551 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1552 ok(ses1_ctl
== ses1_ctl2
, "Got different controls: %p %p\n", ses1_ctl
, ses1_ctl2
);
1553 ref
= IAudioSessionControl2_Release(ses1_ctl2
);
1554 ok(ref
!= 0, "AudioSessionControl was destroyed\n");
1556 hr
= IAudioClient_GetService(ses1_ac2
, &IID_IAudioSessionControl
, (void**)&ses1_ctl2
);
1557 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1559 hr
= IAudioSessionControl2_GetState(ses1_ctl
, NULL
);
1560 ok(hr
== NULL_PTR_ERR
, "GetState gave wrong error: %08x\n", hr
);
1562 hr
= IAudioSessionControl2_GetState(ses1_ctl
, &state
);
1563 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1564 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1566 hr
= IAudioSessionControl2_GetState(ses1_ctl2
, &state
);
1567 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1568 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1571 hr
= IAudioSessionControl2_GetState(cap_ctl
, &state
);
1572 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1573 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1576 hr
= IAudioClient_Start(ses1_ac1
);
1577 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1579 hr
= IAudioSessionControl2_GetState(ses1_ctl
, &state
);
1580 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1581 ok(state
== AudioSessionStateActive
, "Got wrong state: %d\n", state
);
1583 hr
= IAudioSessionControl2_GetState(ses1_ctl2
, &state
);
1584 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1585 ok(state
== AudioSessionStateActive
, "Got wrong state: %d\n", state
);
1588 hr
= IAudioSessionControl2_GetState(cap_ctl
, &state
);
1589 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1590 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1593 hr
= IAudioClient_Stop(ses1_ac1
);
1594 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1596 hr
= IAudioSessionControl2_GetState(ses1_ctl
, &state
);
1597 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1598 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1600 hr
= IAudioSessionControl2_GetState(ses1_ctl2
, &state
);
1601 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1602 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1605 hr
= IAudioSessionControl2_GetState(cap_ctl
, &state
);
1606 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1607 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1609 hr
= IAudioClient_Start(cap_ac
);
1610 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
1612 hr
= IAudioSessionControl2_GetState(ses1_ctl
, &state
);
1613 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1614 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1616 hr
= IAudioSessionControl2_GetState(ses1_ctl2
, &state
);
1617 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1618 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1620 hr
= IAudioSessionControl2_GetState(cap_ctl
, &state
);
1621 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1622 ok(state
== AudioSessionStateActive
, "Got wrong state: %d\n", state
);
1624 hr
= IAudioClient_Stop(cap_ac
);
1625 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
1627 hr
= IAudioSessionControl2_GetState(ses1_ctl
, &state
);
1628 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1629 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1631 hr
= IAudioSessionControl2_GetState(ses1_ctl2
, &state
);
1632 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1633 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1635 hr
= IAudioSessionControl2_GetState(cap_ctl
, &state
);
1636 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1637 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1639 ref
= IAudioSessionControl2_Release(cap_ctl
);
1640 ok(ref
== 0, "AudioSessionControl wasn't released: %u\n", ref
);
1642 ref
= IAudioClient_Release(cap_ac
);
1643 ok(ref
== 0, "AudioClient wasn't released: %u\n", ref
);
1646 ref
= IAudioSessionControl2_Release(ses1_ctl
);
1647 ok(ref
== 0, "AudioSessionControl wasn't released: %u\n", ref
);
1649 ref
= IAudioClient_Release(ses1_ac1
);
1650 ok(ref
== 0, "AudioClient wasn't released: %u\n", ref
);
1652 ref
= IAudioClient_Release(ses1_ac2
);
1653 ok(ref
== 1, "AudioClient had wrong refcount: %u\n", ref
);
1655 /* we've released all of our IAudioClient references, so check GetState */
1656 hr
= IAudioSessionControl2_GetState(ses1_ctl2
, &state
);
1657 ok(hr
== S_OK
, "GetState failed: %08x\n", hr
);
1658 ok(state
== AudioSessionStateInactive
, "Got wrong state: %d\n", state
);
1660 ref
= IAudioSessionControl2_Release(ses1_ctl2
);
1661 ok(ref
== 0, "AudioSessionControl wasn't released: %u\n", ref
);
1663 CoTaskMemFree(pwfx
);
1666 static void test_streamvolume(void)
1669 IAudioStreamVolume
*asv
;
1675 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1677 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1681 hr
= IAudioClient_GetMixFormat(ac
, &fmt
);
1682 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1684 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000,
1686 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
1689 hr
= IAudioClient_GetService(ac
, &IID_IAudioStreamVolume
, (void**)&asv
);
1690 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1693 IAudioClient_Release(ac
);
1698 hr
= IAudioStreamVolume_GetChannelCount(asv
, NULL
);
1699 ok(hr
== E_POINTER
, "GetChannelCount gave wrong error: %08x\n", hr
);
1701 hr
= IAudioStreamVolume_GetChannelCount(asv
, &chans
);
1702 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
1703 ok(chans
== fmt
->nChannels
, "GetChannelCount gave wrong number of channels: %d\n", chans
);
1705 hr
= IAudioStreamVolume_GetChannelVolume(asv
, fmt
->nChannels
, NULL
);
1706 ok(hr
== E_POINTER
, "GetChannelCount gave wrong error: %08x\n", hr
);
1708 hr
= IAudioStreamVolume_GetChannelVolume(asv
, fmt
->nChannels
, &vol
);
1709 ok(hr
== E_INVALIDARG
, "GetChannelCount gave wrong error: %08x\n", hr
);
1711 hr
= IAudioStreamVolume_GetChannelVolume(asv
, 0, NULL
);
1712 ok(hr
== E_POINTER
, "GetChannelCount gave wrong error: %08x\n", hr
);
1714 hr
= IAudioStreamVolume_GetChannelVolume(asv
, 0, &vol
);
1715 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
1716 ok(vol
== 1.f
, "Channel volume was not 1: %f\n", vol
);
1718 hr
= IAudioStreamVolume_SetChannelVolume(asv
, fmt
->nChannels
, -1.f
);
1719 ok(hr
== E_INVALIDARG
, "SetChannelVolume gave wrong error: %08x\n", hr
);
1721 hr
= IAudioStreamVolume_SetChannelVolume(asv
, 0, -1.f
);
1722 ok(hr
== E_INVALIDARG
, "SetChannelVolume gave wrong error: %08x\n", hr
);
1724 hr
= IAudioStreamVolume_SetChannelVolume(asv
, 0, 2.f
);
1725 ok(hr
== E_INVALIDARG
, "SetChannelVolume gave wrong error: %08x\n", hr
);
1727 hr
= IAudioStreamVolume_SetChannelVolume(asv
, 0, 0.2f
);
1728 ok(hr
== S_OK
, "SetChannelVolume failed: %08x\n", hr
);
1730 hr
= IAudioStreamVolume_GetChannelVolume(asv
, 0, &vol
);
1731 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
1732 ok(fabsf(vol
- 0.2f
) < 0.05f
, "Channel volume wasn't 0.2: %f\n", vol
);
1734 hr
= IAudioStreamVolume_GetAllVolumes(asv
, 0, NULL
);
1735 ok(hr
== E_POINTER
, "GetAllVolumes gave wrong error: %08x\n", hr
);
1737 hr
= IAudioStreamVolume_GetAllVolumes(asv
, fmt
->nChannels
, NULL
);
1738 ok(hr
== E_POINTER
, "GetAllVolumes gave wrong error: %08x\n", hr
);
1740 vols
= HeapAlloc(GetProcessHeap(), 0, fmt
->nChannels
* sizeof(float));
1741 ok(vols
!= NULL
, "HeapAlloc failed\n");
1743 hr
= IAudioStreamVolume_GetAllVolumes(asv
, fmt
->nChannels
- 1, vols
);
1744 ok(hr
== E_INVALIDARG
, "GetAllVolumes gave wrong error: %08x\n", hr
);
1746 hr
= IAudioStreamVolume_GetAllVolumes(asv
, fmt
->nChannels
, vols
);
1747 ok(hr
== S_OK
, "GetAllVolumes failed: %08x\n", hr
);
1748 ok(fabsf(vols
[0] - 0.2f
) < 0.05f
, "Channel 0 volume wasn't 0.2: %f\n", vol
);
1749 for(i
= 1; i
< fmt
->nChannels
; ++i
)
1750 ok(vols
[i
] == 1.f
, "Channel %d volume is not 1: %f\n", i
, vols
[i
]);
1752 hr
= IAudioStreamVolume_SetAllVolumes(asv
, 0, NULL
);
1753 ok(hr
== E_POINTER
, "SetAllVolumes gave wrong error: %08x\n", hr
);
1755 hr
= IAudioStreamVolume_SetAllVolumes(asv
, fmt
->nChannels
, NULL
);
1756 ok(hr
== E_POINTER
, "SetAllVolumes gave wrong error: %08x\n", hr
);
1758 hr
= IAudioStreamVolume_SetAllVolumes(asv
, fmt
->nChannels
- 1, vols
);
1759 ok(hr
== E_INVALIDARG
, "SetAllVolumes gave wrong error: %08x\n", hr
);
1761 hr
= IAudioStreamVolume_SetAllVolumes(asv
, fmt
->nChannels
, vols
);
1762 ok(hr
== S_OK
, "SetAllVolumes failed: %08x\n", hr
);
1764 HeapFree(GetProcessHeap(), 0, vols
);
1765 IAudioStreamVolume_Release(asv
);
1766 IAudioClient_Release(ac
);
1770 static void test_channelvolume(void)
1773 IChannelAudioVolume
*acv
;
1779 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1781 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1785 hr
= IAudioClient_GetMixFormat(ac
, &fmt
);
1786 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1788 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
1789 AUDCLNT_STREAMFLAGS_NOPERSIST
, 5000000, 0, fmt
, NULL
);
1790 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
1793 hr
= IAudioClient_GetService(ac
, &IID_IChannelAudioVolume
, (void**)&acv
);
1794 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1797 IAudioClient_Release(ac
);
1802 hr
= IChannelAudioVolume_GetChannelCount(acv
, NULL
);
1803 ok(hr
== NULL_PTR_ERR
, "GetChannelCount gave wrong error: %08x\n", hr
);
1805 hr
= IChannelAudioVolume_GetChannelCount(acv
, &chans
);
1806 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
1807 ok(chans
== fmt
->nChannels
, "GetChannelCount gave wrong number of channels: %d\n", chans
);
1809 hr
= IChannelAudioVolume_GetChannelVolume(acv
, fmt
->nChannels
, NULL
);
1810 ok(hr
== NULL_PTR_ERR
, "GetChannelCount gave wrong error: %08x\n", hr
);
1812 hr
= IChannelAudioVolume_GetChannelVolume(acv
, fmt
->nChannels
, &vol
);
1813 ok(hr
== E_INVALIDARG
, "GetChannelCount gave wrong error: %08x\n", hr
);
1815 hr
= IChannelAudioVolume_GetChannelVolume(acv
, 0, NULL
);
1816 ok(hr
== NULL_PTR_ERR
, "GetChannelCount gave wrong error: %08x\n", hr
);
1818 hr
= IChannelAudioVolume_GetChannelVolume(acv
, 0, &vol
);
1819 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
1820 ok(vol
== 1.f
, "Channel volume was not 1: %f\n", vol
);
1822 hr
= IChannelAudioVolume_SetChannelVolume(acv
, fmt
->nChannels
, -1.f
, NULL
);
1823 ok(hr
== E_INVALIDARG
, "SetChannelVolume gave wrong error: %08x\n", hr
);
1825 hr
= IChannelAudioVolume_SetChannelVolume(acv
, 0, -1.f
, NULL
);
1826 ok(hr
== E_INVALIDARG
, "SetChannelVolume gave wrong error: %08x\n", hr
);
1828 hr
= IChannelAudioVolume_SetChannelVolume(acv
, 0, 2.f
, NULL
);
1829 ok(hr
== E_INVALIDARG
, "SetChannelVolume gave wrong error: %08x\n", hr
);
1831 hr
= IChannelAudioVolume_SetChannelVolume(acv
, 0, 0.2f
, NULL
);
1832 ok(hr
== S_OK
, "SetChannelVolume failed: %08x\n", hr
);
1834 hr
= IChannelAudioVolume_GetChannelVolume(acv
, 0, &vol
);
1835 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
1836 ok(fabsf(vol
- 0.2f
) < 0.05f
, "Channel volume wasn't 0.2: %f\n", vol
);
1838 hr
= IChannelAudioVolume_GetAllVolumes(acv
, 0, NULL
);
1839 ok(hr
== NULL_PTR_ERR
, "GetAllVolumes gave wrong error: %08x\n", hr
);
1841 hr
= IChannelAudioVolume_GetAllVolumes(acv
, fmt
->nChannels
, NULL
);
1842 ok(hr
== NULL_PTR_ERR
, "GetAllVolumes gave wrong error: %08x\n", hr
);
1844 vols
= HeapAlloc(GetProcessHeap(), 0, fmt
->nChannels
* sizeof(float));
1845 ok(vols
!= NULL
, "HeapAlloc failed\n");
1847 hr
= IChannelAudioVolume_GetAllVolumes(acv
, fmt
->nChannels
- 1, vols
);
1848 ok(hr
== E_INVALIDARG
, "GetAllVolumes gave wrong error: %08x\n", hr
);
1850 hr
= IChannelAudioVolume_GetAllVolumes(acv
, fmt
->nChannels
, vols
);
1851 ok(hr
== S_OK
, "GetAllVolumes failed: %08x\n", hr
);
1852 ok(fabsf(vols
[0] - 0.2f
) < 0.05f
, "Channel 0 volume wasn't 0.2: %f\n", vol
);
1853 for(i
= 1; i
< fmt
->nChannels
; ++i
)
1854 ok(vols
[i
] == 1.f
, "Channel %d volume is not 1: %f\n", i
, vols
[i
]);
1856 hr
= IChannelAudioVolume_SetAllVolumes(acv
, 0, NULL
, NULL
);
1857 ok(hr
== NULL_PTR_ERR
, "SetAllVolumes gave wrong error: %08x\n", hr
);
1859 hr
= IChannelAudioVolume_SetAllVolumes(acv
, fmt
->nChannels
, NULL
, NULL
);
1860 ok(hr
== NULL_PTR_ERR
, "SetAllVolumes gave wrong error: %08x\n", hr
);
1862 hr
= IChannelAudioVolume_SetAllVolumes(acv
, fmt
->nChannels
- 1, vols
, NULL
);
1863 ok(hr
== E_INVALIDARG
, "SetAllVolumes gave wrong error: %08x\n", hr
);
1865 hr
= IChannelAudioVolume_SetAllVolumes(acv
, fmt
->nChannels
, vols
, NULL
);
1866 ok(hr
== S_OK
, "SetAllVolumes failed: %08x\n", hr
);
1868 hr
= IChannelAudioVolume_SetChannelVolume(acv
, 0, 1.0f
, NULL
);
1869 ok(hr
== S_OK
, "SetChannelVolume failed: %08x\n", hr
);
1871 HeapFree(GetProcessHeap(), 0, vols
);
1872 IChannelAudioVolume_Release(acv
);
1873 IAudioClient_Release(ac
);
1877 static void test_simplevolume(void)
1880 ISimpleAudioVolume
*sav
;
1886 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1888 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1892 hr
= IAudioClient_GetMixFormat(ac
, &fmt
);
1893 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1895 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
1896 AUDCLNT_STREAMFLAGS_NOPERSIST
, 5000000, 0, fmt
, NULL
);
1897 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
1900 hr
= IAudioClient_GetService(ac
, &IID_ISimpleAudioVolume
, (void**)&sav
);
1901 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
1904 IAudioClient_Release(ac
);
1909 hr
= ISimpleAudioVolume_GetMasterVolume(sav
, NULL
);
1910 ok(hr
== NULL_PTR_ERR
, "GetMasterVolume gave wrong error: %08x\n", hr
);
1912 hr
= ISimpleAudioVolume_GetMasterVolume(sav
, &vol
);
1913 ok(hr
== S_OK
, "GetMasterVolume failed: %08x\n", hr
);
1914 ok(vol
== 1.f
, "Master volume wasn't 1: %f\n", vol
);
1916 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, -1.f
, NULL
);
1917 ok(hr
== E_INVALIDARG
, "SetMasterVolume gave wrong error: %08x\n", hr
);
1919 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, 2.f
, NULL
);
1920 ok(hr
== E_INVALIDARG
, "SetMasterVolume gave wrong error: %08x\n", hr
);
1922 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, 0.2f
, NULL
);
1923 ok(hr
== S_OK
, "SetMasterVolume failed: %08x\n", hr
);
1925 hr
= ISimpleAudioVolume_GetMasterVolume(sav
, &vol
);
1926 ok(hr
== S_OK
, "GetMasterVolume failed: %08x\n", hr
);
1927 ok(fabsf(vol
- 0.2f
) < 0.05f
, "Master volume wasn't 0.2: %f\n", vol
);
1929 hr
= ISimpleAudioVolume_GetMute(sav
, NULL
);
1930 ok(hr
== NULL_PTR_ERR
, "GetMute gave wrong error: %08x\n", hr
);
1933 hr
= ISimpleAudioVolume_GetMute(sav
, &mute
);
1934 ok(hr
== S_OK
, "GetMute failed: %08x\n", hr
);
1935 ok(mute
== FALSE
, "Session is already muted\n");
1937 hr
= ISimpleAudioVolume_SetMute(sav
, TRUE
, NULL
);
1938 ok(hr
== S_OK
, "SetMute failed: %08x\n", hr
);
1941 hr
= ISimpleAudioVolume_GetMute(sav
, &mute
);
1942 ok(hr
== S_OK
, "GetMute failed: %08x\n", hr
);
1943 ok(mute
== TRUE
, "Session should have been muted\n");
1945 hr
= ISimpleAudioVolume_GetMasterVolume(sav
, &vol
);
1946 ok(hr
== S_OK
, "GetMasterVolume failed: %08x\n", hr
);
1947 ok(fabsf(vol
- 0.2f
) < 0.05f
, "Master volume wasn't 0.2: %f\n", vol
);
1949 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, 1.f
, NULL
);
1950 ok(hr
== S_OK
, "SetMasterVolume failed: %08x\n", hr
);
1953 hr
= ISimpleAudioVolume_GetMute(sav
, &mute
);
1954 ok(hr
== S_OK
, "GetMute failed: %08x\n", hr
);
1955 ok(mute
== TRUE
, "Session should have been muted\n");
1957 hr
= ISimpleAudioVolume_SetMute(sav
, FALSE
, NULL
);
1958 ok(hr
== S_OK
, "SetMute failed: %08x\n", hr
);
1960 ISimpleAudioVolume_Release(sav
);
1961 IAudioClient_Release(ac
);
1965 static void test_volume_dependence(void)
1967 IAudioClient
*ac
, *ac2
;
1968 ISimpleAudioVolume
*sav
;
1969 IChannelAudioVolume
*cav
;
1970 IAudioStreamVolume
*asv
;
1977 hr
= CoCreateGuid(&session
);
1978 ok(hr
== S_OK
, "CoCreateGuid failed: %08x\n", hr
);
1980 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
1982 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
1986 hr
= IAudioClient_GetMixFormat(ac
, &fmt
);
1987 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
1989 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
1990 AUDCLNT_STREAMFLAGS_NOPERSIST
, 5000000, 0, fmt
, &session
);
1991 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
1994 hr
= IAudioClient_GetService(ac
, &IID_ISimpleAudioVolume
, (void**)&sav
);
1995 ok(hr
== S_OK
, "GetService (SimpleAudioVolume) failed: %08x\n", hr
);
1998 IAudioClient_Release(ac
);
2003 hr
= IAudioClient_GetService(ac
, &IID_IChannelAudioVolume
, (void**)&cav
);
2004 ok(hr
== S_OK
, "GetService (ChannelAudioVolme) failed: %08x\n", hr
);
2006 hr
= IAudioClient_GetService(ac
, &IID_IAudioStreamVolume
, (void**)&asv
);
2007 ok(hr
== S_OK
, "GetService (AudioStreamVolume) failed: %08x\n", hr
);
2009 hr
= IAudioStreamVolume_SetChannelVolume(asv
, 0, 0.2f
);
2010 ok(hr
== S_OK
, "ASV_SetChannelVolume failed: %08x\n", hr
);
2012 hr
= IChannelAudioVolume_SetChannelVolume(cav
, 0, 0.4f
, NULL
);
2013 ok(hr
== S_OK
, "CAV_SetChannelVolume failed: %08x\n", hr
);
2015 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, 0.6f
, NULL
);
2016 ok(hr
== S_OK
, "SAV_SetMasterVolume failed: %08x\n", hr
);
2018 hr
= IAudioStreamVolume_GetChannelVolume(asv
, 0, &vol
);
2019 ok(hr
== S_OK
, "ASV_GetChannelVolume failed: %08x\n", hr
);
2020 ok(fabsf(vol
- 0.2f
) < 0.05f
, "ASV_GetChannelVolume gave wrong volume: %f\n", vol
);
2022 hr
= IChannelAudioVolume_GetChannelVolume(cav
, 0, &vol
);
2023 ok(hr
== S_OK
, "CAV_GetChannelVolume failed: %08x\n", hr
);
2024 ok(fabsf(vol
- 0.4f
) < 0.05f
, "CAV_GetChannelVolume gave wrong volume: %f\n", vol
);
2026 hr
= ISimpleAudioVolume_GetMasterVolume(sav
, &vol
);
2027 ok(hr
== S_OK
, "SAV_GetMasterVolume failed: %08x\n", hr
);
2028 ok(fabsf(vol
- 0.6f
) < 0.05f
, "SAV_GetMasterVolume gave wrong volume: %f\n", vol
);
2030 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
2031 NULL
, (void**)&ac2
);
2032 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
2035 hr
= IAudioClient_Initialize(ac2
, AUDCLNT_SHAREMODE_SHARED
,
2036 AUDCLNT_STREAMFLAGS_NOPERSIST
, 5000000, 0, fmt
, &session
);
2037 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
2039 IAudioClient_Release(ac2
);
2043 IChannelAudioVolume
*cav2
;
2044 IAudioStreamVolume
*asv2
;
2046 hr
= IAudioClient_GetService(ac2
, &IID_IChannelAudioVolume
, (void**)&cav2
);
2047 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
2049 hr
= IAudioClient_GetService(ac2
, &IID_IAudioStreamVolume
, (void**)&asv2
);
2050 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
2052 hr
= IChannelAudioVolume_GetChannelVolume(cav2
, 0, &vol
);
2053 ok(hr
== S_OK
, "CAV_GetChannelVolume failed: %08x\n", hr
);
2054 ok(fabsf(vol
- 0.4f
) < 0.05f
, "CAV_GetChannelVolume gave wrong volume: %f\n", vol
);
2056 hr
= IAudioStreamVolume_GetChannelVolume(asv2
, 0, &vol
);
2057 ok(hr
== S_OK
, "ASV_GetChannelVolume failed: %08x\n", hr
);
2058 ok(vol
== 1.f
, "ASV_GetChannelVolume gave wrong volume: %f\n", vol
);
2060 hr
= IChannelAudioVolume_GetChannelCount(cav2
, &nch
);
2061 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
2062 ok(nch
== fmt
->nChannels
, "Got wrong channel count, expected %u: %u\n", fmt
->nChannels
, nch
);
2064 hr
= IAudioStreamVolume_GetChannelCount(asv2
, &nch
);
2065 ok(hr
== S_OK
, "GetChannelCount failed: %08x\n", hr
);
2066 ok(nch
== fmt
->nChannels
, "Got wrong channel count, expected %u: %u\n", fmt
->nChannels
, nch
);
2068 IAudioStreamVolume_Release(asv2
);
2069 IChannelAudioVolume_Release(cav2
);
2070 IAudioClient_Release(ac2
);
2072 skip("Unable to open the same device twice. Skipping session volume control tests\n");
2074 hr
= IChannelAudioVolume_SetChannelVolume(cav
, 0, 1.f
, NULL
);
2075 ok(hr
== S_OK
, "CAV_SetChannelVolume failed: %08x\n", hr
);
2077 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, 1.f
, NULL
);
2078 ok(hr
== S_OK
, "SAV_SetMasterVolume failed: %08x\n", hr
);
2081 ISimpleAudioVolume_Release(sav
);
2082 IChannelAudioVolume_Release(cav
);
2083 IAudioStreamVolume_Release(asv
);
2084 IAudioClient_Release(ac
);
2087 static void test_session_creation(void)
2091 IAudioSessionManager
*sesm
;
2092 ISimpleAudioVolume
*sav
;
2098 CoCreateGuid(&session_guid
);
2100 hr
= IMMDevice_Activate(dev
, &IID_IAudioSessionManager
,
2101 CLSCTX_INPROC_SERVER
, NULL
, (void**)&sesm
);
2102 ok((hr
== S_OK
)^(sesm
== NULL
), "Activate %08x &out pointer\n", hr
);
2103 ok(hr
== S_OK
, "Activate failed: %08x\n", hr
);
2105 hr
= IAudioSessionManager_GetSimpleAudioVolume(sesm
, &session_guid
,
2107 ok(hr
== S_OK
, "GetSimpleAudioVolume failed: %08x\n", hr
);
2109 hr
= ISimpleAudioVolume_SetMasterVolume(sav
, 0.6f
, NULL
);
2110 ok(hr
== S_OK
, "SetMasterVolume failed: %08x\n", hr
);
2112 /* Release completely to show session persistence */
2113 ISimpleAudioVolume_Release(sav
);
2114 IAudioSessionManager_Release(sesm
);
2116 /* test if we can create a capture audioclient in the session we just
2117 * created from a SessionManager derived from a render device */
2118 hr
= IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme
, eCapture
,
2119 eMultimedia
, &cap_dev
);
2121 WAVEFORMATEX
*cap_pwfx
;
2122 IAudioClient
*cap_ac
;
2123 ISimpleAudioVolume
*cap_sav
;
2124 IAudioSessionManager
*cap_sesm
;
2126 hr
= IMMDevice_Activate(cap_dev
, &IID_IAudioSessionManager
,
2127 CLSCTX_INPROC_SERVER
, NULL
, (void**)&cap_sesm
);
2128 ok((hr
== S_OK
)^(cap_sesm
== NULL
), "Activate %08x &out pointer\n", hr
);
2129 ok(hr
== S_OK
, "Activate failed: %08x\n", hr
);
2131 hr
= IAudioSessionManager_GetSimpleAudioVolume(cap_sesm
, &session_guid
,
2133 ok(hr
== S_OK
, "GetSimpleAudioVolume failed: %08x\n", hr
);
2136 hr
= ISimpleAudioVolume_GetMasterVolume(cap_sav
, &vol
);
2137 ok(hr
== S_OK
, "GetMasterVolume failed: %08x\n", hr
);
2138 ok(vol
== 1.f
, "Got wrong volume: %f\n", vol
);
2140 ISimpleAudioVolume_Release(cap_sav
);
2141 IAudioSessionManager_Release(cap_sesm
);
2143 hr
= IMMDevice_Activate(cap_dev
, &IID_IAudioClient
,
2144 CLSCTX_INPROC_SERVER
, NULL
, (void**)&cap_ac
);
2145 ok(hr
== S_OK
, "Activate failed: %08x\n", hr
);
2147 IMMDevice_Release(cap_dev
);
2149 hr
= IAudioClient_GetMixFormat(cap_ac
, &cap_pwfx
);
2150 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
2152 hr
= IAudioClient_Initialize(cap_ac
, AUDCLNT_SHAREMODE_SHARED
,
2153 0, 5000000, 0, cap_pwfx
, &session_guid
);
2154 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
2156 CoTaskMemFree(cap_pwfx
);
2159 hr
= IAudioClient_GetService(cap_ac
, &IID_ISimpleAudioVolume
,
2161 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
2165 hr
= ISimpleAudioVolume_GetMasterVolume(cap_sav
, &vol
);
2166 ok(hr
== S_OK
, "GetMasterVolume failed: %08x\n", hr
);
2167 ok(vol
== 1.f
, "Got wrong volume: %f\n", vol
);
2169 ISimpleAudioVolume_Release(cap_sav
);
2172 IAudioClient_Release(cap_ac
);
2175 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
2177 ok((hr
== S_OK
)^(ac
== NULL
), "Activate %08x &out pointer\n", hr
);
2178 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
2182 hr
= IAudioClient_GetMixFormat(ac
, &fmt
);
2183 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
2185 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
2186 AUDCLNT_STREAMFLAGS_NOPERSIST
, 5000000, 0, fmt
, &session_guid
);
2187 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
2189 hr
= IAudioClient_GetService(ac
, &IID_ISimpleAudioVolume
, (void**)&sav
);
2190 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
2193 hr
= ISimpleAudioVolume_GetMasterVolume(sav
, &vol
);
2194 ok(hr
== S_OK
, "GetMasterVolume failed: %08x\n", hr
);
2195 ok(fabs(vol
- 0.6f
) < 0.05f
, "Got wrong volume: %f\n", vol
);
2197 ISimpleAudioVolume_Release(sav
);
2201 IAudioClient_Release(ac
);
2204 static void test_worst_case(void)
2209 IAudioRenderClient
*arc
;
2212 REFERENCE_TIME defp
;
2213 UINT64 freq
, pos
, pcpos0
, pcpos
;
2216 UINT32 pad
, fragment
, sum
;
2219 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
2221 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
2225 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
2226 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
2228 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
,
2229 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
, 500000, 0, pwfx
, NULL
);
2230 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
2234 hr
= IAudioClient_GetDevicePeriod(ac
, &defp
, NULL
);
2235 ok(hr
== S_OK
, "GetDevicePeriod failed: %08x\n", hr
);
2237 fragment
= MulDiv(defp
, pwfx
->nSamplesPerSec
, 10000000);
2239 event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2240 ok(event
!= NULL
, "CreateEvent failed\n");
2242 hr
= IAudioClient_SetEventHandle(ac
, event
);
2243 ok(hr
== S_OK
, "SetEventHandle failed: %08x\n", hr
);
2245 hr
= IAudioClient_GetService(ac
, &IID_IAudioRenderClient
, (void**)&arc
);
2246 ok(hr
== S_OK
, "GetService(IAudioRenderClient) failed: %08x\n", hr
);
2248 hr
= IAudioClient_GetService(ac
, &IID_IAudioClock
, (void**)&acl
);
2249 ok(hr
== S_OK
, "GetService(IAudioClock) failed: %08x\n", hr
);
2251 hr
= IAudioClock_GetFrequency(acl
, &freq
);
2252 ok(hr
== S_OK
, "GetFrequency failed: %08x\n", hr
);
2254 for(j
= 0; j
<= (winetest_interactive
? 9 : 2); j
++){
2256 trace("Should play %ums continuous tone with fragment size %u.\n",
2257 (ULONG
)(defp
/100), fragment
);
2259 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos0
);
2260 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
2262 /* XAudio2 prefills one period, play without it */
2263 if(winetest_debug
>2){
2264 hr
= IAudioRenderClient_GetBuffer(arc
, fragment
, &data
);
2265 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
2267 hr
= IAudioRenderClient_ReleaseBuffer(arc
, fragment
, AUDCLNT_BUFFERFLAGS_SILENT
);
2268 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
2273 hr
= IAudioClient_Start(ac
);
2274 ok(hr
== S_OK
, "Start failed: %08x\n", hr
);
2276 for(i
= 0; i
<= 99; i
++){ /* 100 x 10ms = 1 second */
2277 r
= WaitForSingleObject(event
, 60 + defp
/ 10000);
2278 ok(r
== WAIT_OBJECT_0
, "Wait iteration %d gave %x\n", i
, r
);
2280 /* the app has nearly one period time to feed data */
2281 Sleep((i
% 10) * defp
/ 120000);
2283 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
2284 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
2286 /* XAudio2 writes only when there's little data left */
2287 if(pad
<= fragment
){
2288 hr
= IAudioRenderClient_GetBuffer(arc
, fragment
, &data
);
2289 ok(hr
== S_OK
, "GetBuffer failed: %08x\n", hr
);
2291 hr
= IAudioRenderClient_ReleaseBuffer(arc
, fragment
,
2292 wave_generate_tone(pwfx
, data
, fragment
));
2293 ok(hr
== S_OK
, "ReleaseBuffer failed: %08x\n", hr
);
2299 hr
= IAudioClient_Stop(ac
);
2300 ok(hr
== S_OK
, "Stop failed: %08x\n", hr
);
2302 hr
= IAudioClient_GetCurrentPadding(ac
, &pad
);
2303 ok(hr
== S_OK
, "GetCurrentPadding failed: %08x\n", hr
);
2305 hr
= IAudioClock_GetPosition(acl
, &pos
, &pcpos
);
2306 ok(hr
== S_OK
, "GetPosition failed: %08x\n", hr
);
2310 trace("Released %u=%ux%u -%u frames at %u worth %ums in %ums\n",
2311 sum
, sum
/fragment
, fragment
, pad
,
2312 pwfx
->nSamplesPerSec
, MulDiv(sum
-pad
, 1000, pwfx
->nSamplesPerSec
),
2313 (ULONG
)((pcpos
-pcpos0
)/10000));
2315 ok(pos
* pwfx
->nSamplesPerSec
== (sum
-pad
) * freq
,
2316 "Position %u at end vs. %u-%u submitted frames\n", (UINT
)pos
, sum
, pad
);
2318 hr
= IAudioClient_Reset(ac
);
2319 ok(hr
== S_OK
, "Reset failed: %08x\n", hr
);
2324 CoTaskMemFree(pwfx
);
2325 IAudioClient_Release(ac
);
2326 IAudioClock_Release(acl
);
2327 IAudioRenderClient_Release(arc
);
2330 static void test_marshal(void)
2333 IAudioClient
*ac
, *acDest
;
2334 IAudioRenderClient
*rc
, *rcDest
;
2338 /* IAudioRenderClient */
2339 hr
= IMMDevice_Activate(dev
, &IID_IAudioClient
, CLSCTX_INPROC_SERVER
,
2341 ok(hr
== S_OK
, "Activation failed with %08x\n", hr
);
2345 hr
= IAudioClient_GetMixFormat(ac
, &pwfx
);
2346 ok(hr
== S_OK
, "GetMixFormat failed: %08x\n", hr
);
2348 hr
= IAudioClient_Initialize(ac
, AUDCLNT_SHAREMODE_SHARED
, 0, 5000000,
2350 ok(hr
== S_OK
, "Initialize failed: %08x\n", hr
);
2352 CoTaskMemFree(pwfx
);
2354 hr
= IAudioClient_GetService(ac
, &IID_IAudioRenderClient
, (void**)&rc
);
2355 ok(hr
== S_OK
, "GetService failed: %08x\n", hr
);
2357 IAudioClient_Release(ac
);
2361 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
2362 ok(hr
== S_OK
, "CreateStreamOnHGlobal failed 0x%08x\n", hr
);
2364 /* marshal IAudioClient */
2366 hr
= CoMarshalInterface(pStream
, &IID_IAudioClient
, (IUnknown
*)ac
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
2367 ok(hr
== S_OK
, "CoMarshalInterface IAudioClient failed 0x%08x\n", hr
);
2369 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
2370 hr
= CoUnmarshalInterface(pStream
, &IID_IAudioClient
, (void **)&acDest
);
2371 ok(hr
== S_OK
, "CoUnmarshalInterface IAudioClient failed 0x%08x\n", hr
);
2373 IAudioClient_Release(acDest
);
2375 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
2376 /* marshal IAudioRenderClient */
2378 hr
= CoMarshalInterface(pStream
, &IID_IAudioRenderClient
, (IUnknown
*)rc
, MSHCTX_INPROC
, NULL
, MSHLFLAGS_NORMAL
);
2379 ok(hr
== S_OK
, "CoMarshalInterface IAudioRenderClient failed 0x%08x\n", hr
);
2381 IStream_Seek(pStream
, ullZero
, STREAM_SEEK_SET
, NULL
);
2382 hr
= CoUnmarshalInterface(pStream
, &IID_IAudioRenderClient
, (void **)&rcDest
);
2383 ok(hr
== S_OK
, "CoUnmarshalInterface IAudioRenderClient failed 0x%08x\n", hr
);
2385 IAudioRenderClient_Release(rcDest
);
2388 IStream_Release(pStream
);
2390 IAudioClient_Release(ac
);
2391 IAudioRenderClient_Release(rc
);
2399 CoInitializeEx(NULL
, COINIT_MULTITHREADED
);
2400 hr
= CoCreateInstance(&CLSID_MMDeviceEnumerator
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IMMDeviceEnumerator
, (void**)&mme
);
2403 skip("mmdevapi not available: 0x%08x\n", hr
);
2407 hr
= IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme
, eRender
, eMultimedia
, &dev
);
2408 ok(hr
== S_OK
|| hr
== E_NOTFOUND
, "GetDefaultAudioEndpoint failed: 0x%08x\n", hr
);
2409 if (hr
!= S_OK
|| !dev
)
2411 if (hr
== E_NOTFOUND
)
2412 skip("No sound card available\n");
2414 skip("GetDefaultAudioEndpoint returns 0x%08x\n", hr
);
2419 test_formats(AUDCLNT_SHAREMODE_EXCLUSIVE
);
2420 test_formats(AUDCLNT_SHAREMODE_SHARED
);
2424 trace("Output to a MS-DOS console is particularly slow and disturbs timing.\n");
2425 trace("Please redirect output to a file.\n");
2431 test_streamvolume();
2432 test_channelvolume();
2433 test_simplevolume();
2434 test_volume_dependence();
2435 test_session_creation();
2438 IMMDevice_Release(dev
);
2442 IMMDeviceEnumerator_Release(mme
);