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     if (FAILED(hr)) return;
 723
 724     hr = IAudioClient_GetMixFormat(ses1_ac1, &pwfx);
 725     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 726
 727     hr = IAudioClient_Initialize(ses1_ac1, AUDCLNT_SHAREMODE_SHARED,
 728             0, 5000000, 0, pwfx, &ses1_guid);
 729     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 730
 731     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 732             NULL, (void**)&ses1_ac2);
 733     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 734     if (FAILED(hr))
 735     {
 736         IAudioClient_Release(ses1_ac1);
 737         return;
 738     }
 739
 740     hr = IAudioClient_Initialize(ses1_ac2, AUDCLNT_SHAREMODE_SHARED,
 741             0, 5000000, 0, pwfx, &ses1_guid);
 742     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 743
 744     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eCapture,
 745             eMultimedia, &cap_dev);
 746     if(hr == S_OK){
 747         WAVEFORMATEX *cap_pwfx;
 748
 749         hr = IMMDevice_Activate(cap_dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 750                 NULL, (void**)&cap_ac);
 751         ok(hr == S_OK, "Activate failed: %08x\n", hr);
 752
 753         hr = IAudioClient_GetMixFormat(cap_ac, &cap_pwfx);
 754         ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 755
 756         hr = IAudioClient_Initialize(cap_ac, AUDCLNT_SHAREMODE_SHARED,
 757                 0, 5000000, 0, cap_pwfx, &ses1_guid);
 758         ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 759
 760         hr = IAudioClient_GetService(cap_ac, &IID_IAudioSessionControl, (void**)&cap_ctl);
 761         ok(hr == S_OK, "GetService failed: %08x\n", hr);
 762
 763         IMMDevice_Release(cap_dev);
 764         CoTaskMemFree(cap_pwfx);
 765     }else
 766         skip("No capture device available; skipping capture device in render session tests\n");
 767
 768     hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl2, (void**)&ses1_ctl);
 769     ok(hr == E_NOINTERFACE, "GetService gave wrong error: %08x\n", hr);
 770
 771     hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl);
 772     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 773
 774     hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
 775     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 776     ok(ses1_ctl == ses1_ctl2, "Got different controls: %p %p\n", ses1_ctl, ses1_ctl2);
 777     ref = IAudioSessionControl_Release(ses1_ctl2);
 778     ok(ref != 0, "AudioSessionControl was destroyed\n");
 779
 780     hr = IAudioClient_GetService(ses1_ac2, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
 781     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 782
 783     hr = IAudioSessionControl_GetState(ses1_ctl, NULL);
 784     ok(hr == NULL_PTR_ERR, "GetState gave wrong error: %08x\n", hr);
 785
 786     hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 787     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 788     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 789
 790     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 791     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 792     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 793
 794     if(cap_ac){
 795         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 796         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 797         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 798     }
 799
 800     hr = IAudioClient_Start(ses1_ac1);
 801     ok(hr == S_OK, "Start failed: %08x\n", hr);
 802
 803     hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 804     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 805     ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
 806
 807     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 808     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 809     ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
 810
 811     if(cap_ac){
 812         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 813         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 814         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 815     }
 816
 817     hr = IAudioClient_Stop(ses1_ac1);
 818     ok(hr == S_OK, "Start failed: %08x\n", hr);
 819
 820     hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 821     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 822     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 823
 824     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 825     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 826     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 827
 828     if(cap_ac){
 829         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 830         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 831         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 832
 833         hr = IAudioClient_Start(cap_ac);
 834         ok(hr == S_OK, "Start failed: %08x\n", hr);
 835
 836         hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 837         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 838         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 839
 840         hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 841         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 842         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 843
 844         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 845         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 846         ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
 847
 848         hr = IAudioClient_Stop(cap_ac);
 849         ok(hr == S_OK, "Stop failed: %08x\n", hr);
 850
 851         hr = IAudioSessionControl_GetState(ses1_ctl, &state);
 852         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 853         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 854
 855         hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 856         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 857         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 858
 859         hr = IAudioSessionControl_GetState(cap_ctl, &state);
 860         ok(hr == S_OK, "GetState failed: %08x\n", hr);
 861         ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 862
 863         ref = IAudioSessionControl_Release(cap_ctl);
 864         ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
 865
 866         ref = IAudioClient_Release(cap_ac);
 867         ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
 868     }
 869
 870     ref = IAudioSessionControl_Release(ses1_ctl);
 871     ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
 872
 873     ref = IAudioClient_Release(ses1_ac1);
 874     ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
 875
 876     ref = IAudioClient_Release(ses1_ac2);
 877     ok(ref == 1, "AudioClient had wrong refcount: %u\n", ref);
 878
 879     /* we've released all of our IAudioClient references, so check GetState */
 880     hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
 881     ok(hr == S_OK, "GetState failed: %08x\n", hr);
 882     ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
 883
 884     ref = IAudioSessionControl_Release(ses1_ctl2);
 885     ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
 886
 887     CoTaskMemFree(pwfx);
 888 }
 889
 890 static void test_streamvolume(void)
 891 {
 892     IAudioClient *ac;
 893     IAudioStreamVolume *asv;
 894     WAVEFORMATEX *fmt;
 895     UINT32 chans, i;
 896     HRESULT hr;
 897     float vol, *vols;
 898
 899     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 900             NULL, (void**)&ac);
 901     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 902     if(hr != S_OK)
 903         return;
 904
 905     hr = IAudioClient_GetMixFormat(ac, &fmt);
 906     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
 907
 908     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED, 0, 5000000,
 909             0, fmt, NULL);
 910     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
 911
 912     hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
 913     ok(hr == S_OK, "GetService failed: %08x\n", hr);
 914
 915     hr = IAudioStreamVolume_GetChannelCount(asv, NULL);
 916     ok(hr == E_POINTER, "GetChannelCount gave wrong error: %08x\n", hr);
 917
 918     hr = IAudioStreamVolume_GetChannelCount(asv, &chans);
 919     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
 920     ok(chans == fmt->nChannels, "GetChannelCount gave wrong number of channels: %d\n", chans);
 921
 922     hr = IAudioStreamVolume_GetChannelVolume(asv, fmt->nChannels, NULL);
 923     ok(hr == E_POINTER, "GetChannelCount gave wrong error: %08x\n", hr);
 924
 925     hr = IAudioStreamVolume_GetChannelVolume(asv, fmt->nChannels, &vol);
 926     ok(hr == E_INVALIDARG, "GetChannelCount gave wrong error: %08x\n", hr);
 927
 928     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, NULL);
 929     ok(hr == E_POINTER, "GetChannelCount gave wrong error: %08x\n", hr);
 930
 931     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
 932     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
 933     ok(vol == 1.f, "Channel volume was not 1: %f\n", vol);
 934
 935     hr = IAudioStreamVolume_SetChannelVolume(asv, fmt->nChannels, -1.f);
 936     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
 937
 938     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, -1.f);
 939     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
 940
 941     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 2.f);
 942     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
 943
 944     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 0.2f);
 945     ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
 946
 947     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
 948     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
 949     ok(fabsf(vol - 0.2f) < 0.05f, "Channel volume wasn't 0.2: %f\n", vol);
 950
 951     hr = IAudioStreamVolume_GetAllVolumes(asv, 0, NULL);
 952     ok(hr == E_POINTER, "GetAllVolumes gave wrong error: %08x\n", hr);
 953
 954     hr = IAudioStreamVolume_GetAllVolumes(asv, fmt->nChannels, NULL);
 955     ok(hr == E_POINTER, "GetAllVolumes gave wrong error: %08x\n", hr);
 956
 957     vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
 958     ok(vols != NULL, "HeapAlloc failed\n");
 959
 960     hr = IAudioStreamVolume_GetAllVolumes(asv, fmt->nChannels - 1, vols);
 961     ok(hr == E_INVALIDARG, "GetAllVolumes gave wrong error: %08x\n", hr);
 962
 963     hr = IAudioStreamVolume_GetAllVolumes(asv, fmt->nChannels, vols);
 964     ok(hr == S_OK, "GetAllVolumes failed: %08x\n", hr);
 965     ok(fabsf(vols[0] - 0.2f) < 0.05f, "Channel 0 volume wasn't 0.2: %f\n", vol);
 966     for(i = 1; i < fmt->nChannels; ++i)
 967         ok(vols[i] == 1.f, "Channel %d volume is not 1: %f\n", i, vols[i]);
 968
 969     hr = IAudioStreamVolume_SetAllVolumes(asv, 0, NULL);
 970     ok(hr == E_POINTER, "SetAllVolumes gave wrong error: %08x\n", hr);
 971
 972     hr = IAudioStreamVolume_SetAllVolumes(asv, fmt->nChannels, NULL);
 973     ok(hr == E_POINTER, "SetAllVolumes gave wrong error: %08x\n", hr);
 974
 975     hr = IAudioStreamVolume_SetAllVolumes(asv, fmt->nChannels - 1, vols);
 976     ok(hr == E_INVALIDARG, "SetAllVolumes gave wrong error: %08x\n", hr);
 977
 978     hr = IAudioStreamVolume_SetAllVolumes(asv, fmt->nChannels, vols);
 979     ok(hr == S_OK, "SetAllVolumes failed: %08x\n", hr);
 980
 981     HeapFree(GetProcessHeap(), 0, vols);
 982     IAudioStreamVolume_Release(asv);
 983     IAudioClient_Release(ac);
 984     CoTaskMemFree(fmt);
 985 }
 986
 987 static void test_channelvolume(void)
 988 {
 989     IAudioClient *ac;
 990     IChannelAudioVolume *acv;
 991     WAVEFORMATEX *fmt;
 992     UINT32 chans, i;
 993     HRESULT hr;
 994     float vol, *vols;
 995
 996     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
 997             NULL, (void**)&ac);
 998     ok(hr == S_OK, "Activation failed with %08x\n", hr);
 999     if(hr != S_OK)
1000         return;
1001
1002     hr = IAudioClient_GetMixFormat(ac, &fmt);
1003     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1004
1005     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1006             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, NULL);
1007     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1008
1009     hr = IAudioClient_GetService(ac, &IID_IChannelAudioVolume, (void**)&acv);
1010     ok(hr == S_OK, "GetService failed: %08x\n", hr);
1011
1012     hr = IChannelAudioVolume_GetChannelCount(acv, NULL);
1013     ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
1014
1015     hr = IChannelAudioVolume_GetChannelCount(acv, &chans);
1016     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1017     ok(chans == fmt->nChannels, "GetChannelCount gave wrong number of channels: %d\n", chans);
1018
1019     hr = IChannelAudioVolume_GetChannelVolume(acv, fmt->nChannels, NULL);
1020     ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
1021
1022     hr = IChannelAudioVolume_GetChannelVolume(acv, fmt->nChannels, &vol);
1023     ok(hr == E_INVALIDARG, "GetChannelCount gave wrong error: %08x\n", hr);
1024
1025     hr = IChannelAudioVolume_GetChannelVolume(acv, 0, NULL);
1026     ok(hr == NULL_PTR_ERR, "GetChannelCount gave wrong error: %08x\n", hr);
1027
1028     hr = IChannelAudioVolume_GetChannelVolume(acv, 0, &vol);
1029     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1030     ok(vol == 1.f, "Channel volume was not 1: %f\n", vol);
1031
1032     hr = IChannelAudioVolume_SetChannelVolume(acv, fmt->nChannels, -1.f, NULL);
1033     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
1034
1035     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, -1.f, NULL);
1036     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
1037
1038     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 2.f, NULL);
1039     ok(hr == E_INVALIDARG, "SetChannelVolume gave wrong error: %08x\n", hr);
1040
1041     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 0.2f, NULL);
1042     ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
1043
1044     hr = IChannelAudioVolume_GetChannelVolume(acv, 0, &vol);
1045     ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1046     ok(fabsf(vol - 0.2f) < 0.05f, "Channel volume wasn't 0.2: %f\n", vol);
1047
1048     hr = IChannelAudioVolume_GetAllVolumes(acv, 0, NULL);
1049     ok(hr == NULL_PTR_ERR, "GetAllVolumes gave wrong error: %08x\n", hr);
1050
1051     hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels, NULL);
1052     ok(hr == NULL_PTR_ERR, "GetAllVolumes gave wrong error: %08x\n", hr);
1053
1054     vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
1055     ok(vols != NULL, "HeapAlloc failed\n");
1056
1057     hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels - 1, vols);
1058     ok(hr == E_INVALIDARG, "GetAllVolumes gave wrong error: %08x\n", hr);
1059
1060     hr = IChannelAudioVolume_GetAllVolumes(acv, fmt->nChannels, vols);
1061     ok(hr == S_OK, "GetAllVolumes failed: %08x\n", hr);
1062     ok(fabsf(vols[0] - 0.2f) < 0.05f, "Channel 0 volume wasn't 0.2: %f\n", vol);
1063     for(i = 1; i < fmt->nChannels; ++i)
1064         ok(vols[i] == 1.f, "Channel %d volume is not 1: %f\n", i, vols[i]);
1065
1066     hr = IChannelAudioVolume_SetAllVolumes(acv, 0, NULL, NULL);
1067     ok(hr == NULL_PTR_ERR, "SetAllVolumes gave wrong error: %08x\n", hr);
1068
1069     hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels, NULL, NULL);
1070     ok(hr == NULL_PTR_ERR, "SetAllVolumes gave wrong error: %08x\n", hr);
1071
1072     hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels - 1, vols, NULL);
1073     ok(hr == E_INVALIDARG, "SetAllVolumes gave wrong error: %08x\n", hr);
1074
1075     hr = IChannelAudioVolume_SetAllVolumes(acv, fmt->nChannels, vols, NULL);
1076     ok(hr == S_OK, "SetAllVolumes failed: %08x\n", hr);
1077
1078     hr = IChannelAudioVolume_SetChannelVolume(acv, 0, 1.0f, NULL);
1079     ok(hr == S_OK, "SetChannelVolume failed: %08x\n", hr);
1080
1081     HeapFree(GetProcessHeap(), 0, vols);
1082     IChannelAudioVolume_Release(acv);
1083     IAudioClient_Release(ac);
1084     CoTaskMemFree(fmt);
1085 }
1086
1087 static void test_simplevolume(void)
1088 {
1089     IAudioClient *ac;
1090     ISimpleAudioVolume *sav;
1091     WAVEFORMATEX *fmt;
1092     HRESULT hr;
1093     float vol;
1094     BOOL mute;
1095
1096     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1097             NULL, (void**)&ac);
1098     ok(hr == S_OK, "Activation failed with %08x\n", hr);
1099     if(hr != S_OK)
1100         return;
1101
1102     hr = IAudioClient_GetMixFormat(ac, &fmt);
1103     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1104
1105     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1106             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, NULL);
1107     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1108
1109     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
1110     ok(hr == S_OK, "GetService failed: %08x\n", hr);
1111
1112     hr = ISimpleAudioVolume_GetMasterVolume(sav, NULL);
1113     ok(hr == NULL_PTR_ERR, "GetMasterVolume gave wrong error: %08x\n", hr);
1114
1115     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1116     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1117     ok(vol == 1.f, "Master volume wasn't 1: %f\n", vol);
1118
1119     hr = ISimpleAudioVolume_SetMasterVolume(sav, -1.f, NULL);
1120     ok(hr == E_INVALIDARG, "SetMasterVolume gave wrong error: %08x\n", hr);
1121
1122     hr = ISimpleAudioVolume_SetMasterVolume(sav, 2.f, NULL);
1123     ok(hr == E_INVALIDARG, "SetMasterVolume gave wrong error: %08x\n", hr);
1124
1125     hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.2f, NULL);
1126     ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
1127
1128     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1129     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1130     ok(fabsf(vol - 0.2f) < 0.05f, "Master volume wasn't 0.2: %f\n", vol);
1131
1132     hr = ISimpleAudioVolume_GetMute(sav, NULL);
1133     ok(hr == NULL_PTR_ERR, "GetMute gave wrong error: %08x\n", hr);
1134
1135     mute = TRUE;
1136     hr = ISimpleAudioVolume_GetMute(sav, &mute);
1137     ok(hr == S_OK, "GetMute failed: %08x\n", hr);
1138     ok(mute == FALSE, "Session is already muted\n");
1139
1140     hr = ISimpleAudioVolume_SetMute(sav, TRUE, NULL);
1141     ok(hr == S_OK, "SetMute failed: %08x\n", hr);
1142
1143     mute = FALSE;
1144     hr = ISimpleAudioVolume_GetMute(sav, &mute);
1145     ok(hr == S_OK, "GetMute failed: %08x\n", hr);
1146     ok(mute == TRUE, "Session should have been muted\n");
1147
1148     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1149     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1150     ok(fabsf(vol - 0.2f) < 0.05f, "Master volume wasn't 0.2: %f\n", vol);
1151
1152     hr = ISimpleAudioVolume_SetMasterVolume(sav, 1.f, NULL);
1153     ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
1154
1155     mute = FALSE;
1156     hr = ISimpleAudioVolume_GetMute(sav, &mute);
1157     ok(hr == S_OK, "GetMute failed: %08x\n", hr);
1158     ok(mute == TRUE, "Session should have been muted\n");
1159
1160     hr = ISimpleAudioVolume_SetMute(sav, FALSE, NULL);
1161     ok(hr == S_OK, "SetMute failed: %08x\n", hr);
1162
1163     ISimpleAudioVolume_Release(sav);
1164     IAudioClient_Release(ac);
1165     CoTaskMemFree(fmt);
1166 }
1167
1168 static void test_volume_dependence(void)
1169 {
1170     IAudioClient *ac, *ac2;
1171     ISimpleAudioVolume *sav;
1172     IChannelAudioVolume *cav;
1173     IAudioStreamVolume *asv;
1174     WAVEFORMATEX *fmt;
1175     HRESULT hr;
1176     float vol;
1177     GUID session;
1178     UINT32 nch;
1179
1180     hr = CoCreateGuid(&session);
1181     ok(hr == S_OK, "CoCreateGuid failed: %08x\n", hr);
1182
1183     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1184             NULL, (void**)&ac);
1185     ok(hr == S_OK, "Activation failed with %08x\n", hr);
1186
1187     hr = IAudioClient_GetMixFormat(ac, &fmt);
1188     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1189
1190     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1191             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session);
1192     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1193
1194     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
1195     ok(hr == S_OK, "GetService (SimpleAudioVolume) failed: %08x\n", hr);
1196
1197     hr = IAudioClient_GetService(ac, &IID_IChannelAudioVolume, (void**)&cav);
1198     ok(hr == S_OK, "GetService (ChannelAudioVolme) failed: %08x\n", hr);
1199
1200     hr = IAudioClient_GetService(ac, &IID_IAudioStreamVolume, (void**)&asv);
1201     ok(hr == S_OK, "GetService (AudioStreamVolume) failed: %08x\n", hr);
1202
1203     hr = IAudioStreamVolume_SetChannelVolume(asv, 0, 0.2f);
1204     ok(hr == S_OK, "ASV_SetChannelVolume failed: %08x\n", hr);
1205
1206     hr = IChannelAudioVolume_SetChannelVolume(cav, 0, 0.4f, NULL);
1207     ok(hr == S_OK, "CAV_SetChannelVolume failed: %08x\n", hr);
1208
1209     hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.6f, NULL);
1210     ok(hr == S_OK, "SAV_SetMasterVolume failed: %08x\n", hr);
1211
1212     hr = IAudioStreamVolume_GetChannelVolume(asv, 0, &vol);
1213     ok(hr == S_OK, "ASV_GetChannelVolume failed: %08x\n", hr);
1214     ok(fabsf(vol - 0.2) < 0.05f, "ASV_GetChannelVolume gave wrong volume: %f\n", vol);
1215
1216     hr = IChannelAudioVolume_GetChannelVolume(cav, 0, &vol);
1217     ok(hr == S_OK, "CAV_GetChannelVolume failed: %08x\n", hr);
1218     ok(fabsf(vol - 0.4) < 0.05f, "CAV_GetChannelVolume gave wrong volume: %f\n", vol);
1219
1220     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1221     ok(hr == S_OK, "SAV_GetMasterVolume failed: %08x\n", hr);
1222     ok(fabsf(vol - 0.6) < 0.05f, "SAV_GetMasterVolume gave wrong volume: %f\n", vol);
1223
1224     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1225             NULL, (void**)&ac2);
1226     if(SUCCEEDED(hr)){
1227         IChannelAudioVolume *cav2;
1228         IAudioStreamVolume *asv2;
1229
1230         hr = IAudioClient_Initialize(ac2, AUDCLNT_SHAREMODE_SHARED,
1231                 AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session);
1232         ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1233
1234         hr = IAudioClient_GetService(ac2, &IID_IChannelAudioVolume, (void**)&cav2);
1235         ok(hr == S_OK, "GetService failed: %08x\n", hr);
1236
1237         hr = IAudioClient_GetService(ac2, &IID_IAudioStreamVolume, (void**)&asv2);
1238         ok(hr == S_OK, "GetService failed: %08x\n", hr);
1239
1240         hr = IChannelAudioVolume_GetChannelVolume(cav2, 0, &vol);
1241         ok(hr == S_OK, "CAV_GetChannelVolume failed: %08x\n", hr);
1242         ok(fabsf(vol - 0.4) < 0.05f, "CAV_GetChannelVolume gave wrong volume: %f\n", vol);
1243
1244         hr = IAudioStreamVolume_GetChannelVolume(asv2, 0, &vol);
1245         ok(hr == S_OK, "ASV_GetChannelVolume failed: %08x\n", hr);
1246         ok(vol == 1.f, "ASV_GetChannelVolume gave wrong volume: %f\n", vol);
1247
1248         hr = IChannelAudioVolume_GetChannelCount(cav2, &nch);
1249         ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1250         ok(nch == fmt->nChannels, "Got wrong channel count, expected %u: %u\n", fmt->nChannels, nch);
1251
1252         hr = IAudioStreamVolume_GetChannelCount(asv2, &nch);
1253         ok(hr == S_OK, "GetChannelCount failed: %08x\n", hr);
1254         ok(nch == fmt->nChannels, "Got wrong channel count, expected %u: %u\n", fmt->nChannels, nch);
1255
1256         IAudioStreamVolume_Release(asv2);
1257         IChannelAudioVolume_Release(cav2);
1258         IAudioClient_Release(ac2);
1259     }else
1260         skip("Unable to open the same device twice. Skipping session volume control tests\n");
1261
1262     hr = IChannelAudioVolume_SetChannelVolume(cav, 0, 1.f, NULL);
1263     ok(hr == S_OK, "CAV_SetChannelVolume failed: %08x\n", hr);
1264
1265     hr = ISimpleAudioVolume_SetMasterVolume(sav, 1.f, NULL);
1266     ok(hr == S_OK, "SAV_SetMasterVolume failed: %08x\n", hr);
1267
1268     CoTaskMemFree(fmt);
1269     ISimpleAudioVolume_Release(sav);
1270     IChannelAudioVolume_Release(cav);
1271     IAudioStreamVolume_Release(asv);
1272     IAudioClient_Release(ac);
1273 }
1274
1275 static void test_session_creation(void)
1276 {
1277     IMMDevice *cap_dev;
1278     IAudioClient *ac;
1279     IAudioSessionManager *sesm;
1280     ISimpleAudioVolume *sav;
1281     GUID session_guid;
1282     float vol;
1283     HRESULT hr;
1284     WAVEFORMATEX *fmt;
1285
1286     CoCreateGuid(&session_guid);
1287
1288     hr = IMMDevice_Activate(dev, &IID_IAudioSessionManager,
1289             CLSCTX_INPROC_SERVER, NULL, (void**)&sesm);
1290     ok(hr == S_OK, "Activate failed: %08x\n", hr);
1291
1292     hr = IAudioSessionManager_GetSimpleAudioVolume(sesm, &session_guid,
1293             FALSE, &sav);
1294     ok(hr == S_OK, "GetSimpleAudioVolume failed: %08x\n", hr);
1295
1296     hr = ISimpleAudioVolume_SetMasterVolume(sav, 0.6f, NULL);
1297     ok(hr == S_OK, "SetMasterVolume failed: %08x\n", hr);
1298
1299     /* Release completely to show session persistence */
1300     ISimpleAudioVolume_Release(sav);
1301     IAudioSessionManager_Release(sesm);
1302
1303     /* test if we can create a capture audioclient in the session we just
1304      * created from a SessionManager derived from a render device */
1305     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eCapture,
1306             eMultimedia, &cap_dev);
1307     if(hr == S_OK){
1308         WAVEFORMATEX *cap_pwfx;
1309         IAudioClient *cap_ac;
1310         ISimpleAudioVolume *cap_sav;
1311         IAudioSessionManager *cap_sesm;
1312
1313         hr = IMMDevice_Activate(cap_dev, &IID_IAudioSessionManager,
1314                 CLSCTX_INPROC_SERVER, NULL, (void**)&cap_sesm);
1315         ok(hr == S_OK, "Activate failed: %08x\n", hr);
1316
1317         hr = IAudioSessionManager_GetSimpleAudioVolume(cap_sesm, &session_guid,
1318                 FALSE, &cap_sav);
1319         ok(hr == S_OK, "GetSimpleAudioVolume failed: %08x\n", hr);
1320
1321         vol = 0.5f;
1322         hr = ISimpleAudioVolume_GetMasterVolume(cap_sav, &vol);
1323         ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1324         ok(vol == 1.f, "Got wrong volume: %f\n", vol);
1325
1326         ISimpleAudioVolume_Release(cap_sav);
1327         IAudioSessionManager_Release(cap_sesm);
1328
1329         hr = IMMDevice_Activate(cap_dev, &IID_IAudioClient,
1330                 CLSCTX_INPROC_SERVER, NULL, (void**)&cap_ac);
1331         ok(hr == S_OK, "Activate failed: %08x\n", hr);
1332
1333         hr = IAudioClient_GetMixFormat(cap_ac, &cap_pwfx);
1334         ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1335
1336         hr = IAudioClient_Initialize(cap_ac, AUDCLNT_SHAREMODE_SHARED,
1337                 0, 5000000, 0, cap_pwfx, &session_guid);
1338         ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1339
1340         hr = IAudioClient_GetService(cap_ac, &IID_ISimpleAudioVolume,
1341                 (void**)&cap_sav);
1342         ok(hr == S_OK, "GetService failed: %08x\n", hr);
1343
1344         vol = 0.5f;
1345         hr = ISimpleAudioVolume_GetMasterVolume(cap_sav, &vol);
1346         ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1347         ok(vol == 1.f, "Got wrong volume: %f\n", vol);
1348
1349         CoTaskMemFree(cap_pwfx);
1350         ISimpleAudioVolume_Release(cap_sav);
1351         IAudioClient_Release(cap_ac);
1352         IMMDevice_Release(cap_dev);
1353     }
1354
1355     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
1356             NULL, (void**)&ac);
1357     ok(hr == S_OK, "Activation failed with %08x\n", hr);
1358
1359     hr = IAudioClient_GetMixFormat(ac, &fmt);
1360     ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
1361
1362     hr = IAudioClient_Initialize(ac, AUDCLNT_SHAREMODE_SHARED,
1363             AUDCLNT_STREAMFLAGS_NOPERSIST, 5000000, 0, fmt, &session_guid);
1364     ok(hr == S_OK, "Initialize failed: %08x\n", hr);
1365
1366     hr = IAudioClient_GetService(ac, &IID_ISimpleAudioVolume, (void**)&sav);
1367     ok(hr == S_OK, "GetService failed: %08x\n", hr);
1368
1369     vol = 0.5f;
1370     hr = ISimpleAudioVolume_GetMasterVolume(sav, &vol);
1371     ok(hr == S_OK, "GetMasterVolume failed: %08x\n", hr);
1372     ok(fabs(vol - 0.6f) < 0.05f, "Got wrong volume: %f\n", vol);
1373
1374     CoTaskMemFree(fmt);
1375     ISimpleAudioVolume_Release(sav);
1376     IAudioClient_Release(ac);
1377 }
1378
1379 START_TEST(render)
1380 {
1381     HRESULT hr;
1382
1383     CoInitializeEx(NULL, COINIT_MULTITHREADED);
1384     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&mme);
1385     if (FAILED(hr))
1386     {
1387         skip("mmdevapi not available: 0x%08x\n", hr);
1388         goto cleanup;
1389     }
1390
1391     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eRender, eMultimedia, &dev);
1392     ok(hr == S_OK || hr == E_NOTFOUND, "GetDefaultAudioEndpoint failed: 0x%08x\n", hr);
1393     if (hr != S_OK || !dev)
1394     {
1395         if (hr == E_NOTFOUND)
1396             skip("No sound card available\n");
1397         else
1398             skip("GetDefaultAudioEndpoint returns 0x%08x\n", hr);
1399         goto cleanup;
1400     }
1401
1402     test_audioclient();
1403     test_references();
1404     test_event();
1405     test_padding();
1406     test_clock();
1407     test_session();
1408     test_streamvolume();
1409     test_channelvolume();
1410     test_simplevolume();
1411     test_volume_dependence();
1412     test_session_creation();
1413
1414     IMMDevice_Release(dev);
1415
1416 cleanup:
1417     if (mme)
1418         IMMDeviceEnumerator_Release(mme);
1419     CoUninitialize();
1420 }