git.oblomov.eu Git - wine/blob - dlls/mmdevapi/tests/render.c

   1 /*
   2  * Copyright 2010 Maarten Lankhorst for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 /* This test is for audio playback specific mechanisms
  20  * Tests:
  21  * - IAudioClient with eRender and IAudioRenderClient
  22  */
  23
  24 #include <math.h>
  25 #include <stdio.h>
  26
  27 #include "wine/test.h"
  28
  29 #define COBJMACROS
  30
  31 #ifdef STANDALONE
  32 #include "initguid.h"
  33 #endif
  34
  35 #include "unknwn.h"
  36 #include "uuids.h"
  37 #include "mmdeviceapi.h"
  38 #include "audioclient.h"
  39 #include "audiopolicy.h"
  40
  41 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
  42
  43 static IMMDeviceEnumerator *mme = NULL;
  44 static IMMDevice *dev = NULL;
  45
  46 static inline const char *dbgstr_guid( const GUID *id )
  47 {
  48     static char ret[256];
  49     sprintf(ret, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
  50                              id->Data1, id->Data2, id->Data3,
  51                              id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
  52                              id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
  53     return ret;
  54 }
  55
  56 static void test_uninitialized(IAudioClient *ac)
  57 {
  58     HRESULT hr;
  59     UINT32 num;
  60     REFERENCE_TIME t1;
  61
  62     HANDLE handle = CreateEventW(NULL, FALSE, FALSE, NULL);
  63     IUnknown *unk;
  64
  65     hr = IAudioClient_GetBufferSize(ac, &num);
  66     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized GetBufferSize call returns %08x\n", hr);
  67
  68     hr = IAudioClient_GetStreamLatency(ac, &t1);
  69     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized GetStreamLatency call returns %08x\n", hr);
  70
  71     hr = IAudioClient_GetCurrentPadding(ac, &num);
  72     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized GetCurrentPadding call returns %08x\n", hr);
  73
  74     hr = IAudioClient_Start(ac);
  75     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized Start call returns %08x\n", hr);
  76
  77     hr = IAudioClient_Stop(ac);
  78     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized Stop call returns %08x\n", hr);
  79
  80     hr = IAudioClient_Reset(ac);
  81     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized Reset call returns %08x\n", hr);
  82
  83     hr = IAudioClient_SetEventHandle(ac, handle);
  84     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized SetEventHandle call returns %08x\n", hr);
  85
  86     hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&unk);
  87     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Uninitialized GetService call returns %08x\n", hr);
  88
  89     CloseHandle(handle);
  90 }
  91
  92 static void test_audioclient(void)
  93 {
  94     IAudioClient *ac;
  95     IUnknown *unk;
  96     HRESULT hr;
  97     ULONG ref;
  98     WAVEFORMATEX *pwfx, *pwfx2;
  99     REFERENCE_TIME t1, t2;
 100     HANDLE handle;
 101
 102     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 103             NULL, (void**)&ac);
 104     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 105     if(hr != S_OK)
 106         return;
 107
 108     handle = CreateEventW(NULL, FALSE, FALSE, NULL);
 109
 110     hr = IAudioClient_QueryInterface(ac, &IID_IUnknown, NULL);
 111     ok(hr == E_POINTER, "QueryInterface(NULL) returned %08x\n", hr);
 112
 113     unk = (void*)(LONG_PTR)0x12345678;
 114     hr = IAudioClient_QueryInterface(ac, &IID_NULL, (void**)&unk);
 115     ok(hr == E_NOINTERFACE, "QueryInterface(IID_NULL) returned %08x\n", hr);
 116     ok(!unk, "QueryInterface(IID_NULL) returned non-null pointer %p\n", unk);
 117
 118     hr = IAudioClient_QueryInterface(ac, &IID_IUnknown, (void**)&unk);
 119     ok(hr == S_OK, "QueryInterface(IID_IUnknown) returned %08x\n", hr);
 120     if (unk)
 121     {
 122         ref = IUnknown_Release(unk);
 123         ok(ref == 1, "Released count is %u\n", ref);
 124     }
 125
 126     hr = IAudioClient_QueryInterface(ac, &IID_IAudioClient, (void**)&unk);
 127     ok(hr == S_OK, "QueryInterface(IID_IAudioClient) returned %08x\n", hr);
 128     if (unk)
 129     {
 130         ref = IUnknown_Release(unk);
 131         ok(ref == 1, "Released count is %u\n", ref);
 132     }
 133
 134     hr = IAudioClient_GetDevicePeriod(ac, NULL, NULL);
 135     ok(hr == E_POINTER, "Invalid GetDevicePeriod call returns %08x\n", hr);
 136
 137     hr = IAudioClient_GetDevicePeriod(ac, &t1, NULL);
 138     ok(hr == S_OK, "Valid GetDevicePeriod call returns %08x\n", hr);
 139
 140     hr = IAudioClient_GetDevicePeriod(ac, NULL, &t2);
 141     ok(hr == S_OK, "Valid GetDevicePeriod call returns %08x\n", hr);
 142
 143     hr = IAudioClient_GetDevicePeriod(ac, &t1, &t2);
 144     ok(hr == S_OK, "Valid GetDevicePeriod call returns %08x\n", hr);
 145     trace("Returned periods: %u.%05u ms %u.%05u ms\n",
 146           (UINT)(t1/10000), (UINT)(t1 % 10000),
 147           (UINT)(t2/10000), (UINT)(t2 % 10000));
 148
 149     hr = IAudioClient_GetMixFormat(ac, NULL);
 150     ok(hr == E_POINTER, "GetMixFormat returns %08x\n", hr);
 151
 152     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 153     ok(hr == S_OK, "Valid GetMixFormat returns %08x\n", hr);
 154
 155     if (hr == S_OK)
 156     {
 157         trace("pwfx: %p\n", pwfx);
 158         trace("Tag: %04x\n", pwfx->wFormatTag);
 159         trace("bits: %u\n", pwfx->wBitsPerSample);
 160         trace("chan: %u\n", pwfx->nChannels);
 161         trace("rate: %u\n", pwfx->nSamplesPerSec);
 162         trace("align: %u\n", pwfx->nBlockAlign);
 163         trace("extra: %u\n", pwfx->cbSize);
 164         ok(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE, "wFormatTag is %x\n", pwfx->wFormatTag);
 165         if (pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 166         {
 167             WAVEFORMATEXTENSIBLE *pwfxe = (void*)pwfx;
 168             trace("Res: %u\n", pwfxe->Samples.wReserved);
 169             trace("Mask: %x\n", pwfxe->dwChannelMask);
 170             trace("Alg: %s\n",
 171                   IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)?"PCM":
 172                   (IsEqualGUID(&pwfxe->SubFormat,
 173                                &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)?"FLOAT":"Other"));
 174         }
 175
 176         hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, pwfx, &pwfx2);
 177         ok(hr == S_OK, "Valid IsFormatSupported(Shared) call returns %08x\n", hr);
 178         ok(pwfx2 == NULL, "pwfx2 is non-null\n");
 179         CoTaskMemFree(pwfx2);
 180
 181         hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, NULL, NULL);
 182         ok(hr == E_POINTER, "IsFormatSupported(NULL) call returns %08x\n", hr);
 183
 184         hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, pwfx, NULL);
 185         ok(hr == E_POINTER, "IsFormatSupported(Shared,NULL) call returns %08x\n", hr);
 186
 187         hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_EXCLUSIVE, pwfx, NULL);
 188         ok(hr == S_OK || hr == AUDCLNT_E_UNSUPPORTED_FORMAT, "IsFormatSupported(Exclusive) call returns %08x\n", hr);
 189
 190         hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_EXCLUSIVE, pwfx, &pwfx2);
 191         ok(hr == S_OK || hr == AUDCLNT_E_UNSUPPORTED_FORMAT, "IsFormatSupported(Exclusive) call returns %08x\n", hr);
 192         ok(pwfx2 == NULL, "pwfx2 non-null on exclusive IsFormatSupported\n");
 193
 194         hr = IAudioClient_IsFormatSupported(ac, 0xffffffff, pwfx, NULL);
 195         ok(hr == E_INVALIDARG ||
 196            hr == AUDCLNT_E_UNSUPPORTED_FORMAT,
 197            "IsFormatSupported(0xffffffff) call returns %08x\n", hr);
 198     }
 199
 200     test_uninitialized(ac);
 201
 202     hr = IAudioClient_Initialize(ac, 3, 0, 5000000, 0, pwfx, NULL);
 203     ok(hr == AUDCLNT_E_NOT_INITIALIZED, "Initialize with invalid sharemode returns %08x\n", hr);
 204
 205     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0xffffffff, 5000000, 0, pwfx, NULL);
 206     ok(hr == E_INVALIDARG, "Initialize with invalid flags returns %08x\n", hr);
 207
 208     /* It seems that if length > 2s or periodicity != 0 the length is ignored and call succeeds
 209      * Since we can only initialize successfully once, skip those tests.
 210      */
 211     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, NULL, NULL);
 212     ok(hr == E_POINTER, "Initialize with null format returns %08x\n", hr);
 213
 214     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 0, 0, pwfx, NULL);
 215     ok(hr == S_OK, "Initialize with 0 buffer size returns %08x\n", hr);
 216
 217     IAudioClient_Release(ac);
 218
 219     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 220             NULL, (void**)&ac);
 221     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 222
 223     if(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
 224         WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)pwfx;
 225         WAVEFORMATEX *fmt2 = NULL;
 226
 227         ok(fmtex->dwChannelMask != 0, "Got empty dwChannelMask\n");
 228
 229         fmtex->dwChannelMask = 0xffff;
 230
 231         hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, pwfx, NULL);
 232         ok(hr == S_OK, "Initialize(dwChannelMask = 0xffff) returns %08x\n", hr);
 233
 234         IAudioClient_Release(ac);
 235
 236         hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 237                 NULL, (void**)&ac);
 238         ok(hr == S_OK, "Activation failed with %08x\n", hr);
 239
 240         fmtex->dwChannelMask = 0;
 241
 242         hr = IAudioClient_IsFormatSupported(ac, AUDCLNT_SHAREMODE_SHARED, pwfx, &fmt2);
 243         ok(hr == S_OK, "IsFormatSupported(dwChannelMask = 0) call returns %08x\n", hr);
 244         ok(fmtex->dwChannelMask == 0, "Passed format was modified\n");
 245
 246         CoTaskMemFree(fmt2);
 247
 248         hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, pwfx, NULL);
 249         ok(hr == S_OK, "Initialize(dwChannelMask = 0) returns %08x\n", hr);
 250
 251         IAudioClient_Release(ac);
 252
 253         hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 254                 NULL, (void**)&ac);
 255         ok(hr == S_OK, "Activation failed with %08x\n", hr);
 256
 257         CoTaskMemFree(pwfx);
 258
 259         hr = IAudioClient_GetMixFormat(ac, &pwfx);
 260         ok(hr == S_OK, "Valid GetMixFormat returns %08x\n", hr);
 261     }else
 262         skip("Skipping dwChannelMask tests\n");
 263
 264     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, pwfx, NULL);
 265     ok(hr == S_OK, "Valid Initialize returns %08x\n", hr);
 266
 267     if (hr != S_OK)
 268     {
 269         skip("Cannot initialize %08x, remainder of tests is useless\n", hr);
 270         CoTaskMemFree(pwfx);
 271         return;
 272     }
 273
 274     hr = IAudioClient_GetStreamLatency(ac, NULL);
 275     ok(hr == E_POINTER, "GetStreamLatency(NULL) call returns %08x\n", hr);
 276
 277     hr = IAudioClient_GetStreamLatency(ac, &t1);
 278     ok(hr == S_OK, "Valid GetStreamLatency call returns %08x\n", hr);
 279     trace("Returned latency: %u.%05u ms\n",
 280           (UINT)(t1/10000), (UINT)(t1 % 10000));
 281
 282     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000, 0, pwfx, NULL);
 283     ok(hr == AUDCLNT_E_ALREADY_INITIALIZED, "Calling Initialize twice returns %08x\n", hr);
 284
 285     hr = IAudioClient_SetEventHandle(ac, NULL);
 286     ok(hr == E_INVALIDARG, "SetEventHandle(NULL) returns %08x\n", hr);
 287
 288     hr = IAudioClient_SetEventHandle(ac, handle);
 289     ok(hr == AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED ||
 290        broken(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME)) ||
 291        broken(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) /* Some 2k8 */ ||
 292        broken(hr == HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME)) /* Some Vista */
 293        , "SetEventHandle returns %08x\n", hr);
 294
 295     hr = IAudioClient_Reset(ac);
 296     ok(hr == S_OK, "Reset on a resetted stream returns %08x\n", hr);
 297
 298     hr = IAudioClient_Stop(ac);
 299     ok(hr == S_FALSE, "Stop on a stopped stream returns %08x\n", hr);
 300
 301     hr = IAudioClient_Start(ac);
 302     ok(hr == S_OK, "Start on a stopped stream returns %08x\n", hr);
 303
 304     IAudioClient_Release(ac);
 305
 306     CloseHandle(handle);
 307     CoTaskMemFree(pwfx);
 308 }
 309
 310 static void test_references(void)
 311 {
 312     IAudioClient *ac;
 313     IAudioRenderClient *rc;
 314     ISimpleAudioVolume *sav;
 315     IAudioStreamVolume *asv;
 316     IAudioClock *acl;
 317     WAVEFORMATEX *pwfx;
 318     HRESULT hr;
 319     ULONG ref;
 320
 321     /* IAudioRenderClient */
 322     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 323             NULL, (void**)&ac);
 324     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 325     if(hr != S_OK)
 326         return;
 327
 328     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 329     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 330     if(hr != S_OK)
 331         return;
 332
 333     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
 334             0, pwfx, NULL);
 335     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 336
 337     CoTaskMemFree(pwfx);
 338
 339     hr = IAudioClient_GetService(ac, &IID_IAudioRenderClient, (void**)&rc);
 340     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 341
 342     IAudioRenderClient_AddRef(rc);
 343     ref = IAudioRenderClient_Release(rc);
 344     ok(ref != 0, "RenderClient_Release gave wrong refcount: %u\n", ref);
 345
 346     ref = IAudioClient_Release(ac);
 347     ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
 348
 349     ref = IAudioRenderClient_Release(rc);
 350     ok(ref == 0, "RenderClient_Release gave wrong refcount: %u\n", ref);
 351
 352     /* ISimpleAudioVolume */
 353     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 354             NULL, (void**)&ac);
 355     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 356     if(hr != S_OK)
 357         return;
 358
 359     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 360     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 361
 362     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
 363             0, pwfx, NULL);
 364     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 365
 366     CoTaskMemFree(pwfx);
 367
 368     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
 369     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 370
 371     ISimpleAudioVolume_AddRef(sav);
 372     ref = ISimpleAudioVolume_Release(sav);
 373     ok(ref != 0, "SimpleAudioVolume_Release gave wrong refcount: %u\n", ref);
 374
 375     ref = IAudioClient_Release(ac);
 376     ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
 377
 378     ref = ISimpleAudioVolume_Release(sav);
 379     ok(ref == 0, "SimpleAudioVolume_Release gave wrong refcount: %u\n", ref);
 380
 381     /* IAudioClock */
 382     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 383             NULL, (void**)&ac);
 384     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 385     if(hr != S_OK)
 386         return;
 387
 388     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 389     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 390
 391     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
 392             0, pwfx, NULL);
 393     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 394
 395     CoTaskMemFree(pwfx);
 396
 397     hr = IAudioClient_GetService(ac, &IID_IAudioClock, (void**)&acl);
 398     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 399
 400     IAudioClock_AddRef(acl);
 401     ref = IAudioClock_Release(acl);
 402     ok(ref != 0, "AudioClock_Release gave wrong refcount: %u\n", ref);
 403
 404     ref = IAudioClient_Release(ac);
 405     ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
 406
 407     ref = IAudioClock_Release(acl);
 408     ok(ref == 0, "AudioClock_Release gave wrong refcount: %u\n", ref);
 409
 410     /* IAudioStreamVolume */
 411     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 412             NULL, (void**)&ac);
 413     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 414     if(hr != S_OK)
 415         return;
 416
 417     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 418     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 419
 420     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
 421             0, pwfx, NULL);
 422     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 423
 424     CoTaskMemFree(pwfx);
 425
 426     hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
 427     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 428
 429     IAudioStreamVolume_AddRef(asv);
 430     ref = IAudioStreamVolume_Release(asv);
 431     ok(ref != 0, "AudioStreamVolume_Release gave wrong refcount: %u\n", ref);
 432
 433     ref = IAudioClient_Release(ac);
 434     ok(ref != 0, "Client_Release gave wrong refcount: %u\n", ref);
 435
 436     ref = IAudioStreamVolume_Release(asv);
 437     ok(ref == 0, "AudioStreamVolume_Release gave wrong refcount: %u\n", ref);
 438 }
 439
 440 static void test_event(void)
 441 {
 442     HANDLE event;
 443     HRESULT hr;
 444     IAudioClient *ac;
 445     WAVEFORMATEX *pwfx;
 446
 447     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 448             NULL, (void**)&ac);
 449     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 450     if(hr != S_OK)
 451         return;
 452
 453     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 454     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 455     if(hr != S_OK)
 456         return;
 457
 458     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
 459             AUDCLNT_STREAMFLAGS_EVENTCALLBACK, 5000000,
 460             0, pwfx, NULL);
 461     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 462
 463     CoTaskMemFree(pwfx);
 464
 465     event = CreateEventW(NULL, FALSE, FALSE, NULL);
 466     ok(event != NULL, "CreateEvent failed\n");
 467
 468     hr = IAudioClient_Start(ac);
 469     ok(hr == AUDCLNT_E_EVENTHANDLE_NOT_SET, "Start failed: %08x\n", hr);
 470
 471     hr = IAudioClient_SetEventHandle(ac, event);
 472     ok(hr == S_OK, "SetEventHandle failed: %08x\n", hr);
 473
 474     hr = IAudioClient_Start(ac);
 475     ok(hr == S_OK, "Start failed: %08x\n", hr);
 476
 477     hr = IAudioClient_Stop(ac);
 478     ok(hr == S_OK, "Start failed: %08x\n", hr);
 479
 480     /* test releasing a playing stream */
 481     hr = IAudioClient_Start(ac);
 482     ok(hr == S_OK, "Start failed: %08x\n", hr);
 483     IAudioClient_Release(ac);
 484
 485     CloseHandle(event);
 486 }
 487
 488 static void test_padding(void)
 489 {
 490     HRESULT hr;
 491     IAudioClient *ac;
 492     IAudioRenderClient *arc;
 493     WAVEFORMATEX *pwfx;
 494     REFERENCE_TIME minp, defp;
 495     BYTE *buf;
 496     UINT32 psize, pad, written;
 497
 498     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 499             NULL, (void**)&ac);
 500     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 501     if(hr != S_OK)
 502         return;
 503
 504     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 505     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 506     if(hr != S_OK)
 507         return;
 508
 509     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
 510             0, 5000000, 0, pwfx, NULL);
 511     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 512
 513     hr = IAudioClient_GetDevicePeriod(ac, &defp, &minp);
 514     ok(hr == S_OK, "GetDevicePeriod failed: %08x\n", hr);
 515     ok(defp != 0, "Default period is 0\n");
 516     ok(minp != 0, "Minimum period is 0\n");
 517     ok(minp <= defp, "Mininum period is greater than default period\n");
 518
 519     hr = IAudioClient_GetService(ac, &IID_IAudioRenderClient, (void**)&arc);
 520     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 521
 522     psize = (defp / 10000000.) * pwfx->nSamplesPerSec * 10;
 523
 524     written = 0;
 525     hr = IAudioClient_GetCurrentPadding(ac, &pad);
 526     ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
 527     ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
 528
 529     hr = IAudioRenderClient_GetBuffer(arc, psize, &buf);
 530     ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
 531     ok(buf != NULL, "NULL buffer returned\n");
 532
 533     hr = IAudioRenderClient_ReleaseBuffer(arc, psize,
 534             AUDCLNT_BUFFERFLAGS_SILENT);
 535     ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
 536     written += psize;
 537
 538     hr = IAudioClient_GetCurrentPadding(ac, &pad);
 539     ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
 540     ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
 541
 542     psize = (minp / 10000000.) * pwfx->nSamplesPerSec * 10;
 543
 544     hr = IAudioRenderClient_GetBuffer(arc, psize, &buf);
 545     ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
 546     ok(buf != NULL, "NULL buffer returned\n");
 547
 548     hr = IAudioRenderClient_ReleaseBuffer(arc, psize,
 549             AUDCLNT_BUFFERFLAGS_SILENT);
 550     ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
 551     written += psize;
 552
 553     hr = IAudioClient_GetCurrentPadding(ac, &pad);
 554     ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
 555     ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
 556
 557     /* overfull buffer. requested 1/2s buffer size, so try
 558      * to get a 1/2s buffer, which should fail */
 559     psize = pwfx->nSamplesPerSec / 2.;
 560     hr = IAudioRenderClient_GetBuffer(arc, psize, &buf);
 561     ok(hr == AUDCLNT_E_BUFFER_TOO_LARGE, "GetBuffer gave wrong error: %08x\n", hr);
 562
 563     hr = IAudioRenderClient_ReleaseBuffer(arc, psize, 0);
 564     ok(hr == AUDCLNT_E_OUT_OF_ORDER, "ReleaseBuffer gave wrong error: %08x\n", hr);
 565
 566     hr = IAudioClient_GetCurrentPadding(ac, &pad);
 567     ok(hr == S_OK, "GetCurrentPadding failed: %08x\n", hr);
 568     ok(pad == written, "GetCurrentPadding returned %u, should be %u\n", pad, written);
 569
 570     CoTaskMemFree(pwfx);
 571
 572     IAudioRenderClient_Release(arc);
 573     IAudioClient_Release(ac);
 574 }
 575
 576 static void test_clock(void)
 577 {
 578     HRESULT hr;
 579     IAudioClient *ac;
 580     IAudioClock *acl;
 581     IAudioRenderClient *arc;
 582     UINT64 freq, pos, pcpos, last;
 583     BYTE *data;
 584     WAVEFORMATEX *pwfx;
 585
 586     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 587             NULL, (void**)&ac);
 588     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 589     if(hr != S_OK)
 590         return;
 591
 592     hr = IAudioClient_GetMixFormat(ac, &pwfx);
 593     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 594     if(hr != S_OK)
 595         return;
 596
 597     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
 598             0, 5000000, 0, pwfx, NULL);
 599     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 600
 601     hr = IAudioClient_GetService(ac, &IID_IAudioClock, (void**)&acl);
 602     ok(hr == S_OK, "GetService(IAudioClock) failed: %08x\n", hr);
 603
 604     hr = IAudioClock_GetFrequency(acl, &freq);
 605     ok(hr == S_OK, "GetFrequency failed: %08x\n", hr);
 606
 607     hr = IAudioClock_GetPosition(acl, NULL, NULL);
 608     ok(hr == E_POINTER, "GetPosition wrong error: %08x\n", hr);
 609
 610     pcpos = 0;
 611     hr = IAudioClock_GetPosition(acl, &pos, &pcpos);
 612     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 613     ok(pos == 0, "GetPosition returned non-zero pos before being started\n");
 614     ok(pcpos != 0, "GetPosition returned zero pcpos\n");
 615
 616     hr = IAudioClient_GetService(ac, &IID_IAudioRenderClient, (void**)&arc);
 617     ok(hr == S_OK, "GetService(IAudioRenderClient) failed: %08x\n", hr);
 618
 619     hr = IAudioRenderClient_GetBuffer(arc, pwfx->nSamplesPerSec / 2., &data);
 620     ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
 621
 622     hr = IAudioRenderClient_ReleaseBuffer(arc, pwfx->nSamplesPerSec / 2., AUDCLNT_BUFFERFLAGS_SILENT);
 623     ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
 624
 625     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 626     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 627     ok(pos == 0, "GetPosition returned non-zero pos before being started\n");
 628
 629     hr = IAudioClient_Start(ac);
 630     ok(hr == S_OK, "Start failed: %08x\n", hr);
 631
 632     Sleep(100);
 633
 634     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 635     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 636     ok(pos > 0, "Position should have been further along...\n");
 637     last = pos;
 638
 639     hr = IAudioClient_Stop(ac);
 640     ok(hr == S_OK, "Stop failed: %08x\n", hr);
 641
 642     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 643     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 644     ok(pos >= last, "Position should have been further along...\n");
 645     last = pos;
 646
 647     hr = IAudioClient_Start(ac);
 648     ok(hr == S_OK, "Start failed: %08x\n", hr);
 649
 650     Sleep(100);
 651
 652     hr = IAudioClient_Stop(ac);
 653     ok(hr == S_OK, "Stop failed: %08x\n", hr);
 654
 655     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 656     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 657     ok(pos >= last, "Position should have been further along...\n");
 658     last = pos;
 659
 660     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 661     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 662     ok(pos == last, "Position should have been further along...\n");
 663
 664     hr = IAudioClient_Reset(ac);
 665     ok(hr == S_OK, "Reset failed: %08x\n", hr);
 666
 667     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 668     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 669     ok(pos == 0, "GetPosition returned non-zero pos after Reset\n");
 670
 671     hr = IAudioRenderClient_GetBuffer(arc, pwfx->nSamplesPerSec / 2., &data);
 672     ok(hr == S_OK, "GetBuffer failed: %08x\n", hr);
 673
 674     hr = IAudioRenderClient_ReleaseBuffer(arc, pwfx->nSamplesPerSec / 2., AUDCLNT_BUFFERFLAGS_SILENT);
 675     ok(hr == S_OK, "ReleaseBuffer failed: %08x\n", hr);
 676
 677     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 678     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 679     ok(pos == 0, "GetPosition returned non-zero pos after Reset\n");
 680     last = pos;
 681
 682     hr = IAudioClient_Start(ac);
 683     ok(hr == S_OK, "Start failed: %08x\n", hr);
 684
 685     Sleep(100);
 686
 687     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 688     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 689     ok(pos > last, "Position should have been further along...\n");
 690
 691     hr = IAudioClient_Stop(ac);
 692     ok(hr == S_OK, "Stop failed: %08x\n", hr);
 693
 694     hr = IAudioClock_GetPosition(acl, &pos, NULL);
 695     ok(hr == S_OK, "GetPosition failed: %08x\n", hr);
 696     ok(pos >= last, "Position should have been further along...\n");
 697
 698     CoTaskMemFree(pwfx);
 699
 700     IAudioClock_Release(acl);
 701     IAudioRenderClient_Release(arc);
 702     IAudioClient_Release(ac);
 703 }
 704
 705 static void test_session(void)
 706 {
 707     IAudioClient *ses1_ac1, *ses1_ac2, *cap_ac = NULL;
 708     IAudioSessionControl2 *ses1_ctl, *ses1_ctl2, *cap_ctl;
 709     IMMDevice *cap_dev;
 710     GUID ses1_guid;
 711     AudioSessionState state;
 712     WAVEFORMATEX *pwfx;
 713     ULONG ref;
 714     HRESULT hr;
 715
 716     hr = CoCreateGuid(&ses1_guid);
 717     ok(hr == S_OK, "CoCreateGuid failed: %08x\n", hr);
 718
 719     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 720             NULL, (void**)&ses1_ac1);
 721     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 722
 723     hr = IAudioClient_GetMixFormat(ses1_ac1, &pwfx);
 724     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 725
 726     hr = IAudioClient_Initialize(ses1_ac1, AUDCLNT_SHAREMODE_SHARED,
 727             0, 5000000, 0, pwfx, &ses1_guid);
 728     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 729
 730     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 731             NULL, (void**)&ses1_ac2);
 732     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 733
 734     hr = IAudioClient_Initialize(ses1_ac2, AUDCLNT_SHAREMODE_SHARED,
 735             0, 5000000, 0, pwfx, &ses1_guid);
 736     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 737
 738     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eCapture,
 739             eMultimedia, &cap_dev);
 740     if(hr == S_OK){
 741         WAVEFORMATEX *cap_pwfx;
 742
 743         hr = IMMDevice_Activate(cap_dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 744                 NULL, (void**)&cap_ac);
 745         ok(hr == S_OK, "Activate failed: %08x\n", hr);
 746
 747         hr = IAudioClient_GetMixFormat(cap_ac, &cap_pwfx);
 748         ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 749
 750         hr = IAudioClient_Initialize(cap_ac, AUDCLNT_SHAREMODE_SHARED,
 751                 0, 5000000, 0, cap_pwfx, &ses1_guid);
 752         ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 753
 754         hr = IAudioClient_GetService(cap_ac, &IID_IAudioSessionControl, (void**)&cap_ctl);
 755         ok(hr == S_OK, "GetService failed: %08x\n", hr);
 756
 757         IMMDevice_Release(cap_dev);
 758         CoTaskMemFree(cap_pwfx);
 759     }else
 760         skip("No capture device available; skipping capture device in render session tests\n");
 761
 762     hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl2, (void**)&ses1_ctl);
 763     ok(hr == E_NOINTERFACE, "GetService gave wrong error: %08x\n", hr);
 764
 765     hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl);
 766     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 767
 768     hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
 769     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 770     ok(ses1_ctl == ses1_ctl2, "Got different controls: %p %p\n", ses1_ctl, ses1_ctl2);
 771     ref = IAudioSessionControl_Release(ses1_ctl2);
 772     ok(ref != 0, "AudioSessionControl was destroyed\n");
 773
 774     hr = IAudioClient_GetService(ses1_ac2, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
 775     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 776
 777     hr = IAudioSessionControl_GetState(ses1_ctl, NULL);
 778     ok(hr == NULL_PTR_ERR, "GetState gave wrong error: %08x\n", hr);
 779
 780     hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 781     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 782     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 783
 784     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 785     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 786     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 787
 788     if(cap_ac){
 789         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 790         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 791         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 792     }
 793
 794     hr = IAudioClient_Start(ses1_ac1);
 795     ok(hr == S_OK, "Start failed: %08x\n", hr);
 796
 797     hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 798     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 799     ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
 800
 801     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 802     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 803     ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
 804
 805     if(cap_ac){
 806         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 807         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 808         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 809     }
 810
 811     hr = IAudioClient_Stop(ses1_ac1);
 812     ok(hr == S_OK, "Start failed: %08x\n", hr);
 813
 814     hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 815     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 816     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 817
 818     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 819     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 820     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 821
 822     if(cap_ac){
 823         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 824         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 825         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 826
 827         hr = IAudioClient_Start(cap_ac);
 828         ok(hr == S_OK, "Start failed: %08x\n", hr);
 829
 830         hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 831         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 832         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 833
 834         hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 835         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 836         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 837
 838         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 839         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 840         ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
 841
 842         hr = IAudioClient_Stop(cap_ac);
 843         ok(hr == S_OK, "Stop failed: %08x\n", hr);
 844
 845         hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 846         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 847         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 848
 849         hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 850         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 851         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 852
 853         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 854         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 855         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 856
 857         ref = IAudioSessionControl_Release(cap_ctl);
 858         ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
 859
 860         ref = IAudioClient_Release(cap_ac);
 861         ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
 862     }
 863
 864     ref = IAudioSessionControl_Release(ses1_ctl);
 865     ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
 866
 867     ref = IAudioClient_Release(ses1_ac1);
 868     ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
 869
 870     ref = IAudioClient_Release(ses1_ac2);
 871     ok(ref == 1, "AudioClient had wrong refcount: %u\n", ref);
 872
 873     /* we've released all of our IAudioClient references, so check GetState */
 874     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 875     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 876     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 877
 878     ref = IAudioSessionControl_Release(ses1_ctl2);
 879     ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
 880
 881     CoTaskMemFree(pwfx);
 882 }
 883
 884 static void test_streamvolume(void)
 885 {
 886     IAudioClient *ac;
 887     IAudioStreamVolume *asv;
 888     WAVEFORMATEX *fmt;
 889     UINT32 chans, i;
 890     HRESULT hr;
 891     float vol, *vols;
 892
 893     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 894             NULL, (void**)&ac);
 895     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 896     if(hr != S_OK)
 897         return;
 898
 899     hr = IAudioClient_GetMixFormat(ac, &fmt);
 900     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 901
 902     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
 903             0, fmt, NULL);
 904     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 905
 906     hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
 907     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 908
 909     hr = IAudioStreamVolume_GetChannelCount(asv, NULL);
 910     ok(hr == E_POINTER, "GetChannelCount gave wrong error: %08x\n", hr);
 911
 912     hr = IAudioStreamVolume_GetChannelCount(asv, &chans);
 913     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
 914     ok(chans == fmt->nChannels, "GetChannelCount gave wrong number of channels: %d\n", chans);
 915
 916     hr = IAudioStreamVolume_GetChannelVolume(asv, fmt->nChannels, NULL);
 917     ok(hr == E_POINTER, "GetChannelCount gave wrong error: %08x\n", hr);
 918
 919     hr = IAudioStreamVolume_GetChannelVolume(asv, fmt->nChannels, &vol);
 920     ok(hr == E_INVALIDARG, "GetChannelCount gave wrong error: %08x\n", hr);
 921
 922     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, NULL);
 923     ok(hr == E_POINTER, "GetChannelCount gave wrong error: %08x\n", hr);
 924
 925     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
 926     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
 927     ok(vol == 1.f, "Channel volume was not 1: %f\n", vol);
 928
 929     hr = IAudioStreamVolume_SetChannelVolume(asv, fmt->nChannels, -1.f);
 930     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
 931
 932     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, -1.f);
 933     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
 934
 935     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 2.f);
 936     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
 937
 938     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 0.2f);
 939     ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
 940
 941     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
 942     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
 943     ok(fabsf(vol - 0.2f) < 0.05f, "Channel volume wasn't 0.2: %f\n", vol);
 944
 945     hr = IAudioStreamVolume_GetAllVolumes(asv, 0, NULL);
 946     ok(hr == E_POINTER, "GetAllVolumes gave wrong error: %08x\n", hr);
 947
 948     hr = IAudioStreamVolume_GetAllVolumes(asv, fmt->nChannels, NULL);
 949     ok(hr == E_POINTER, "GetAllVolumes gave wrong error: %08x\n", hr);
 950
 951     vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
 952     ok(vols != NULL, "HeapAlloc failed\n");
 953
 954     hr = IAudioStreamVolume_GetAllVolumes(asv, fmt->nChannels - 1, vols);
 955     ok(hr == E_INVALIDARG, "GetAllVolumes gave wrong error: %08x\n", hr);
 956
 957     hr = IAudioStreamVolume_GetAllVolumes(asv, fmt->nChannels, vols);
 958     ok(hr == S_OK, "GetAllVolumes failed: %08x\n", hr);
 959     ok(fabsf(vols[0] - 0.2f) < 0.05f, "Channel 0 volume wasn't 0.2: %f\n", vol);
 960     for(i = 1; i < fmt->nChannels; ++i)
 961         ok(vols[i] == 1.f, "Channel %d volume is not 1: %f\n", i, vols[i]);
 962
 963     hr = IAudioStreamVolume_SetAllVolumes(asv, 0, NULL);
 964     ok(hr == E_POINTER, "SetAllVolumes gave wrong error: %08x\n", hr);
 965
 966     hr = IAudioStreamVolume_SetAllVolumes(asv, fmt->nChannels, NULL);
 967     ok(hr == E_POINTER, "SetAllVolumes gave wrong error: %08x\n", hr);
 968
 969     hr = IAudioStreamVolume_SetAllVolumes(asv, fmt->nChannels - 1, vols);
 970     ok(hr == E_INVALIDARG, "SetAllVolumes gave wrong error: %08x\n", hr);
 971
 972     hr = IAudioStreamVolume_SetAllVolumes(asv, fmt->nChannels, vols);
 973     ok(hr == S_OK, "SetAllVolumes failed: %08x\n", hr);
 974
 975     HeapFree(GetProcessHeap(), 0, vols);
 976     IAudioStreamVolume_Release(asv);
 977     IAudioClient_Release(ac);
 978     CoTaskMemFree(fmt);
 979 }
 980
 981 static void test_channelvolume(void)
 982 {
 983     IAudioClient *ac;
 984     IChannelAudioVolume *acv;
 985     WAVEFORMATEX *fmt;
 986     UINT32 chans, i;
 987     HRESULT hr;
 988     float vol, *vols;
 989
 990     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 991             NULL, (void**)&ac);
 992     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 993     if(hr != S_OK)
 994         return;
 995
 996     hr = IAudioClient_GetMixFormat(ac, &fmt);
 997     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 998
 999     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1000             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, NULL);
1001     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1002
1003     hr = IAudioClient_GetService(ac, &IID_IChannelAudioVolume, (void**)&acv);
1004     ok(hr == S_OK, "GetService failed: %08x\n", hr);
1005
1006     hr = IChannelAudioVolume_GetChannelCount(acv, NULL);
1007     ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
1008
1009     hr = IChannelAudioVolume_GetChannelCount(acv, &chans);
1010     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1011     ok(chans == fmt->nChannels, "GetChannelCount gave wrong number of channels: %d\n", chans);
1012
1013     hr = IChannelAudioVolume_GetChannelVolume(acv, fmt->nChannels, NULL);
1014     ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
1015
1016     hr = IChannelAudioVolume_GetChannelVolume(acv, fmt->nChannels, &vol);
1017     ok(hr == E_INVALIDARG, "GetChannelCount gave wrong error: %08x\n", hr);
1018
1019     hr = IChannelAudioVolume_GetChannelVolume(acv, 0, NULL);
1020     ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
1021
1022     hr = IChannelAudioVolume_GetChannelVolume(acv, 0, &vol);
1023     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1024     ok(vol == 1.f, "Channel volume was not 1: %f\n", vol);
1025
1026     hr = IChannelAudioVolume_SetChannelVolume(acv, fmt->nChannels, -1.f, NULL);
1027     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
1028
1029     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, -1.f, NULL);
1030     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
1031
1032     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 2.f, NULL);
1033     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
1034
1035     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 0.2f, NULL);
1036     ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
1037
1038     hr = IChannelAudioVolume_GetChannelVolume(acv, 0, &vol);
1039     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1040     ok(fabsf(vol - 0.2f) < 0.05f, "Channel volume wasn't 0.2: %f\n", vol);
1041
1042     hr = IChannelAudioVolume_GetAllVolumes(acv, 0, NULL);
1043     ok(hr == NULL_PTR_ERR, "GetAllVolumes gave wrong error: %08x\n", hr);
1044
1045     hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels, NULL);
1046     ok(hr == NULL_PTR_ERR, "GetAllVolumes gave wrong error: %08x\n", hr);
1047
1048     vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
1049     ok(vols != NULL, "HeapAlloc failed\n");
1050
1051     hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels - 1, vols);
1052     ok(hr == E_INVALIDARG, "GetAllVolumes gave wrong error: %08x\n", hr);
1053
1054     hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels, vols);
1055     ok(hr == S_OK, "GetAllVolumes failed: %08x\n", hr);
1056     ok(fabsf(vols[0] - 0.2f) < 0.05f, "Channel 0 volume wasn't 0.2: %f\n", vol);
1057     for(i = 1; i < fmt->nChannels; ++i)
1058         ok(vols[i] == 1.f, "Channel %d volume is not 1: %f\n", i, vols[i]);
1059
1060     hr = IChannelAudioVolume_SetAllVolumes(acv, 0, NULL, NULL);
1061     ok(hr == NULL_PTR_ERR, "SetAllVolumes gave wrong error: %08x\n", hr);
1062
1063     hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels, NULL, NULL);
1064     ok(hr == NULL_PTR_ERR, "SetAllVolumes gave wrong error: %08x\n", hr);
1065
1066     hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels - 1, vols, NULL);
1067     ok(hr == E_INVALIDARG, "SetAllVolumes gave wrong error: %08x\n", hr);
1068
1069     hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels, vols, NULL);
1070     ok(hr == S_OK, "SetAllVolumes failed: %08x\n", hr);
1071
1072     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 1.0f, NULL);
1073     ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
1074
1075     HeapFree(GetProcessHeap(), 0, vols);
1076     IChannelAudioVolume_Release(acv);
1077     IAudioClient_Release(ac);
1078     CoTaskMemFree(fmt);
1079 }
1080
1081 static void test_simplevolume(void)
1082 {
1083     IAudioClient *ac;
1084     ISimpleAudioVolume *sav;
1085     WAVEFORMATEX *fmt;
1086     HRESULT hr;
1087     float vol;
1088     BOOL mute;
1089
1090     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1091             NULL, (void**)&ac);
1092     ok(hr == S_OK, "Activation failed with %08x\n", hr);
1093     if(hr != S_OK)
1094         return;
1095
1096     hr = IAudioClient_GetMixFormat(ac, &fmt);
1097     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1098
1099     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1100             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, NULL);
1101     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1102
1103     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
1104     ok(hr == S_OK, "GetService failed: %08x\n", hr);
1105
1106     hr = ISimpleAudioVolume_GetMasterVolume(sav, NULL);
1107     ok(hr == NULL_PTR_ERR, "GetMasterVolume gave wrong error: %08x\n", hr);
1108
1109     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1110     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1111     ok(vol == 1.f, "Master volume wasn't 1: %f\n", vol);
1112
1113     hr = ISimpleAudioVolume_SetMasterVolume(sav, -1.f, NULL);
1114     ok(hr == E_INVALIDARG, "SetMasterVolume gave wrong error: %08x\n", hr);
1115
1116     hr = ISimpleAudioVolume_SetMasterVolume(sav, 2.f, NULL);
1117     ok(hr == E_INVALIDARG, "SetMasterVolume gave wrong error: %08x\n", hr);
1118
1119     hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.2f, NULL);
1120     ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
1121
1122     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1123     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1124     ok(fabsf(vol - 0.2f) < 0.05f, "Master volume wasn't 0.2: %f\n", vol);
1125
1126     hr = ISimpleAudioVolume_GetMute(sav, NULL);
1127     ok(hr == NULL_PTR_ERR, "GetMute gave wrong error: %08x\n", hr);
1128
1129     mute = TRUE;
1130     hr = ISimpleAudioVolume_GetMute(sav, &mute);
1131     ok(hr == S_OK, "GetMute failed: %08x\n", hr);
1132     ok(mute == FALSE, "Session is already muted\n");
1133
1134     hr = ISimpleAudioVolume_SetMute(sav, TRUE, NULL);
1135     ok(hr == S_OK, "SetMute failed: %08x\n", hr);
1136
1137     mute = FALSE;
1138     hr = ISimpleAudioVolume_GetMute(sav, &mute);
1139     ok(hr == S_OK, "GetMute failed: %08x\n", hr);
1140     ok(mute == TRUE, "Session should have been muted\n");
1141
1142     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1143     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1144     ok(fabsf(vol - 0.2f) < 0.05f, "Master volume wasn't 0.2: %f\n", vol);
1145
1146     hr = ISimpleAudioVolume_SetMasterVolume(sav, 1.f, NULL);
1147     ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
1148
1149     mute = FALSE;
1150     hr = ISimpleAudioVolume_GetMute(sav, &mute);
1151     ok(hr == S_OK, "GetMute failed: %08x\n", hr);
1152     ok(mute == TRUE, "Session should have been muted\n");
1153
1154     hr = ISimpleAudioVolume_SetMute(sav, FALSE, NULL);
1155     ok(hr == S_OK, "SetMute failed: %08x\n", hr);
1156
1157     ISimpleAudioVolume_Release(sav);
1158     IAudioClient_Release(ac);
1159     CoTaskMemFree(fmt);
1160 }
1161
1162 static void test_volume_dependence(void)
1163 {
1164     IAudioClient *ac, *ac2;
1165     ISimpleAudioVolume *sav;
1166     IChannelAudioVolume *cav;
1167     IAudioStreamVolume *asv;
1168     WAVEFORMATEX *fmt;
1169     HRESULT hr;
1170     float vol;
1171     GUID session;
1172     UINT32 nch;
1173
1174     hr = CoCreateGuid(&session);
1175     ok(hr == S_OK, "CoCreateGuid failed: %08x\n", hr);
1176
1177     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1178             NULL, (void**)&ac);
1179     ok(hr == S_OK, "Activation failed with %08x\n", hr);
1180
1181     hr = IAudioClient_GetMixFormat(ac, &fmt);
1182     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1183
1184     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1185             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session);
1186     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1187
1188     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
1189     ok(hr == S_OK, "GetService (SimpleAudioVolume) failed: %08x\n", hr);
1190
1191     hr = IAudioClient_GetService(ac, &IID_IChannelAudioVolume, (void**)&cav);
1192     ok(hr == S_OK, "GetService (ChannelAudioVolme) failed: %08x\n", hr);
1193
1194     hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
1195     ok(hr == S_OK, "GetService (AudioStreamVolume) failed: %08x\n", hr);
1196
1197     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 0.2f);
1198     ok(hr == S_OK, "ASV_SetChannelVolume failed: %08x\n", hr);
1199
1200     hr = IChannelAudioVolume_SetChannelVolume(cav, 0, 0.4f, NULL);
1201     ok(hr == S_OK, "CAV_SetChannelVolume failed: %08x\n", hr);
1202
1203     hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.6f, NULL);
1204     ok(hr == S_OK, "SAV_SetMasterVolume failed: %08x\n", hr);
1205
1206     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
1207     ok(hr == S_OK, "ASV_GetChannelVolume failed: %08x\n", hr);
1208     ok(fabsf(vol - 0.2) < 0.05f, "ASV_GetChannelVolume gave wrong volume: %f\n", vol);
1209
1210     hr = IChannelAudioVolume_GetChannelVolume(cav, 0, &vol);
1211     ok(hr == S_OK, "CAV_GetChannelVolume failed: %08x\n", hr);
1212     ok(fabsf(vol - 0.4) < 0.05f, "CAV_GetChannelVolume gave wrong volume: %f\n", vol);
1213
1214     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1215     ok(hr == S_OK, "SAV_GetMasterVolume failed: %08x\n", hr);
1216     ok(fabsf(vol - 0.6) < 0.05f, "SAV_GetMasterVolume gave wrong volume: %f\n", vol);
1217
1218     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1219             NULL, (void**)&ac2);
1220     if(SUCCEEDED(hr)){
1221         IChannelAudioVolume *cav2;
1222         IAudioStreamVolume *asv2;
1223
1224         hr = IAudioClient_Initialize(ac2, AUDCLNT_SHAREMODE_SHARED,
1225                 AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session);
1226         ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1227
1228         hr = IAudioClient_GetService(ac2, &IID_IChannelAudioVolume, (void**)&cav2);
1229         ok(hr == S_OK, "GetService failed: %08x\n", hr);
1230
1231         hr = IAudioClient_GetService(ac2, &IID_IAudioStreamVolume, (void**)&asv2);
1232         ok(hr == S_OK, "GetService failed: %08x\n", hr);
1233
1234         hr = IChannelAudioVolume_GetChannelVolume(cav2, 0, &vol);
1235         ok(hr == S_OK, "CAV_GetChannelVolume failed: %08x\n", hr);
1236         ok(fabsf(vol - 0.4) < 0.05f, "CAV_GetChannelVolume gave wrong volume: %f\n", vol);
1237
1238         hr = IAudioStreamVolume_GetChannelVolume(asv2, 0, &vol);
1239         ok(hr == S_OK, "ASV_GetChannelVolume failed: %08x\n", hr);
1240         ok(vol == 1.f, "ASV_GetChannelVolume gave wrong volume: %f\n", vol);
1241
1242         hr = IChannelAudioVolume_GetChannelCount(cav2, &nch);
1243         ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1244         ok(nch == fmt->nChannels, "Got wrong channel count, expected %u: %u\n", fmt->nChannels, nch);
1245
1246         hr = IAudioStreamVolume_GetChannelCount(asv2, &nch);
1247         ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1248         ok(nch == fmt->nChannels, "Got wrong channel count, expected %u: %u\n", fmt->nChannels, nch);
1249
1250         IAudioStreamVolume_Release(asv2);
1251         IChannelAudioVolume_Release(cav2);
1252         IAudioClient_Release(ac2);
1253     }else
1254         skip("Unable to open the same device twice. Skipping session volume control tests\n");
1255
1256     hr = IChannelAudioVolume_SetChannelVolume(cav, 0, 1.f, NULL);
1257     ok(hr == S_OK, "CAV_SetChannelVolume failed: %08x\n", hr);
1258
1259     hr = ISimpleAudioVolume_SetMasterVolume(sav, 1.f, NULL);
1260     ok(hr == S_OK, "SAV_SetMasterVolume failed: %08x\n", hr);
1261
1262     CoTaskMemFree(fmt);
1263     ISimpleAudioVolume_Release(sav);
1264     IChannelAudioVolume_Release(cav);
1265     IAudioStreamVolume_Release(asv);
1266     IAudioClient_Release(ac);
1267 }
1268
1269 static void test_session_creation(void)
1270 {
1271     IMMDevice *cap_dev;
1272     IAudioClient *ac;
1273     IAudioSessionManager *sesm;
1274     ISimpleAudioVolume *sav;
1275     GUID session_guid;
1276     float vol;
1277     HRESULT hr;
1278     WAVEFORMATEX *fmt;
1279
1280     CoCreateGuid(&session_guid);
1281
1282     hr = IMMDevice_Activate(dev, &IID_IAudioSessionManager,
1283             CLSCTX_INPROC_SERVER, NULL, (void**)&sesm);
1284     ok(hr == S_OK, "Activate failed: %08x\n", hr);
1285
1286     hr = IAudioSessionManager_GetSimpleAudioVolume(sesm, &session_guid,
1287             FALSE, &sav);
1288     ok(hr == S_OK, "GetSimpleAudioVolume failed: %08x\n", hr);
1289
1290     hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.6f, NULL);
1291     ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
1292
1293     /* Release completely to show session persistence */
1294     ISimpleAudioVolume_Release(sav);
1295     IAudioSessionManager_Release(sesm);
1296
1297     /* test if we can create a capture audioclient in the session we just
1298      * created from a SessionManager derived from a render device */
1299     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eCapture,
1300             eMultimedia, &cap_dev);
1301     if(hr == S_OK){
1302         WAVEFORMATEX *cap_pwfx;
1303         IAudioClient *cap_ac;
1304         ISimpleAudioVolume *cap_sav;
1305         IAudioSessionManager *cap_sesm;
1306
1307         hr = IMMDevice_Activate(cap_dev, &IID_IAudioSessionManager,
1308                 CLSCTX_INPROC_SERVER, NULL, (void**)&cap_sesm);
1309         ok(hr == S_OK, "Activate failed: %08x\n", hr);
1310
1311         hr = IAudioSessionManager_GetSimpleAudioVolume(cap_sesm, &session_guid,
1312                 FALSE, &cap_sav);
1313         ok(hr == S_OK, "GetSimpleAudioVolume failed: %08x\n", hr);
1314
1315         vol = 0.5f;
1316         hr = ISimpleAudioVolume_GetMasterVolume(cap_sav, &vol);
1317         ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1318         ok(vol == 1.f, "Got wrong volume: %f\n", vol);
1319
1320         ISimpleAudioVolume_Release(cap_sav);
1321         IAudioSessionManager_Release(cap_sesm);
1322
1323         hr = IMMDevice_Activate(cap_dev, &IID_IAudioClient,
1324                 CLSCTX_INPROC_SERVER, NULL, (void**)&cap_ac);
1325         ok(hr == S_OK, "Activate failed: %08x\n", hr);
1326
1327         hr = IAudioClient_GetMixFormat(cap_ac, &cap_pwfx);
1328         ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1329
1330         hr = IAudioClient_Initialize(cap_ac, AUDCLNT_SHAREMODE_SHARED,
1331                 0, 5000000, 0, cap_pwfx, &session_guid);
1332         ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1333
1334         hr = IAudioClient_GetService(cap_ac, &IID_ISimpleAudioVolume,
1335                 (void**)&cap_sav);
1336         ok(hr == S_OK, "GetService failed: %08x\n", hr);
1337
1338         vol = 0.5f;
1339         hr = ISimpleAudioVolume_GetMasterVolume(cap_sav, &vol);
1340         ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1341         ok(vol == 1.f, "Got wrong volume: %f\n", vol);
1342
1343         CoTaskMemFree(cap_pwfx);
1344         ISimpleAudioVolume_Release(cap_sav);
1345         IAudioClient_Release(cap_ac);
1346         IMMDevice_Release(cap_dev);
1347     }
1348
1349     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1350             NULL, (void**)&ac);
1351     ok(hr == S_OK, "Activation failed with %08x\n", hr);
1352
1353     hr = IAudioClient_GetMixFormat(ac, &fmt);
1354     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1355
1356     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1357             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session_guid);
1358     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1359
1360     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
1361     ok(hr == S_OK, "GetService failed: %08x\n", hr);
1362
1363     vol = 0.5f;
1364     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1365     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1366     ok(fabs(vol - 0.6f) < 0.05f, "Got wrong volume: %f\n", vol);
1367
1368     CoTaskMemFree(fmt);
1369     ISimpleAudioVolume_Release(sav);
1370     IAudioClient_Release(ac);
1371 }
1372
1373 START_TEST(render)
1374 {
1375     HRESULT hr;
1376
1377     CoInitializeEx(NULL, COINIT_MULTITHREADED);
1378     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&mme);
1379     if (FAILED(hr))
1380     {
1381         skip("mmdevapi not available: 0x%08x\n", hr);
1382         goto cleanup;
1383     }
1384
1385     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eRender, eMultimedia, &dev);
1386     ok(hr == S_OK || hr == E_NOTFOUND, "GetDefaultAudioEndpoint failed: 0x%08x\n", hr);
1387     if (hr != S_OK || !dev)
1388     {
1389         if (hr == E_NOTFOUND)
1390             skip("No sound card available\n");
1391         else
1392             skip("GetDefaultAudioEndpoint returns 0x%08x\n", hr);
1393         goto cleanup;
1394     }
1395
1396     test_audioclient();
1397     test_references();
1398     test_event();
1399     test_padding();
1400     test_clock();
1401     test_session();
1402     test_streamvolume();
1403     test_channelvolume();
1404     test_simplevolume();
1405     test_volume_dependence();
1406     test_session_creation();
1407
1408     IMMDevice_Release(dev);
1409
1410 cleanup:
1411     if (mme)
1412         IMMDeviceEnumerator_Release(mme);
1413     CoUninitialize();
1414 }