dlls/winecoreaudio.drv/mmdevdrv.c

   1 /*
   2  * Copyright 2011 Andrew Eikum 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 #define NONAMELESSUNION
  20 #define COBJMACROS
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnls.h"
  28 #include "winreg.h"
  29 #include "wine/debug.h"
  30 #include "wine/unicode.h"
  31 #include "wine/list.h"
  32
  33 #include "ole2.h"
  34 #include "mmdeviceapi.h"
  35 #include "devpkey.h"
  36 #include "dshow.h"
  37 #include "dsound.h"
  38
  39 #include "initguid.h"
  40 #include "endpointvolume.h"
  41 #include "audioclient.h"
  42 #include "audiopolicy.h"
  43
  44 #include <errno.h>
  45 #include <limits.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <sys/types.h>
  50 #include <sys/stat.h>
  51 #include <sys/ioctl.h>
  52 #include <fcntl.h>
  53 #include <unistd.h>
  54
  55 #include <libkern/OSAtomic.h>
  56 #include <CoreAudio/CoreAudio.h>
  57 #include <AudioToolbox/AudioQueue.h>
  58
  59 WINE_DEFAULT_DEBUG_CHANNEL(coreaudio);
  60
  61 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
  62
  63 #define CAPTURE_BUFFERS 5
  64
  65 static const REFERENCE_TIME DefaultPeriod = 200000;
  66 static const REFERENCE_TIME MinimumPeriod = 100000;
  67
  68 typedef struct _QueuedBufInfo {
  69     Float64 start_sampletime;
  70     UINT64 start_pos;
  71     UINT32 len_frames;
  72     struct list entry;
  73 } QueuedBufInfo;
  74
  75 typedef struct _AQBuffer {
  76     AudioQueueBufferRef buf;
  77     struct list entry;
  78 } AQBuffer;
  79
  80 struct ACImpl;
  81 typedef struct ACImpl ACImpl;
  82
  83 typedef struct _AudioSession {
  84     GUID guid;
  85     struct list clients;
  86
  87     IMMDevice *device;
  88
  89     float master_vol;
  90     UINT32 channel_count;
  91     float *channel_vols;
  92     BOOL mute;
  93
  94     CRITICAL_SECTION lock;
  95
  96     struct list entry;
  97 } AudioSession;
  98
  99 typedef struct _AudioSessionWrapper {
 100     IAudioSessionControl2 IAudioSessionControl2_iface;
 101     IChannelAudioVolume IChannelAudioVolume_iface;
 102     ISimpleAudioVolume ISimpleAudioVolume_iface;
 103
 104     LONG ref;
 105
 106     ACImpl *client;
 107     AudioSession *session;
 108 } AudioSessionWrapper;
 109
 110 struct ACImpl {
 111     IAudioClient IAudioClient_iface;
 112     IAudioRenderClient IAudioRenderClient_iface;
 113     IAudioCaptureClient IAudioCaptureClient_iface;
 114     IAudioClock IAudioClock_iface;
 115     IAudioClock2 IAudioClock2_iface;
 116     IAudioStreamVolume IAudioStreamVolume_iface;
 117
 118     LONG ref;
 119
 120     IMMDevice *parent;
 121
 122     WAVEFORMATEX *fmt;
 123
 124     EDataFlow dataflow;
 125     DWORD flags;
 126     AUDCLNT_SHAREMODE share;
 127     HANDLE event;
 128     float *vols;
 129
 130     AudioDeviceID adevid;
 131     AudioQueueRef aqueue;
 132     AudioObjectPropertyScope scope;
 133     HANDLE timer;
 134     UINT32 period_ms, bufsize_frames, inbuf_frames;
 135     UINT64 last_time, written_frames;
 136     AudioQueueBufferRef public_buffer;
 137     UINT32 getbuf_last;
 138     int playing;
 139
 140     Float64 highest_sampletime;
 141
 142     AudioSession *session;
 143     AudioSessionWrapper *session_wrapper;
 144
 145     struct list entry;
 146
 147     struct list avail_buffers;
 148     struct list queued_bufinfos;
 149
 150     /* We can't use debug printing or {Enter,Leave}CriticalSection from
 151      * OSX callback threads, so we use OSX's OSSpinLock for synchronization
 152      * instead. OSSpinLock is not a recursive lock, so don't call
 153      * synchronized functions while holding the lock. */
 154     OSSpinLock lock;
 155 };
 156
 157 enum PlayingStates {
 158     StateStopped = 0,
 159     StatePlaying,
 160     StateInTransition
 161 };
 162
 163 static const IAudioClientVtbl AudioClient_Vtbl;
 164 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl;
 165 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl;
 166 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl;
 167 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl;
 168 static const IAudioClockVtbl AudioClock_Vtbl;
 169 static const IAudioClock2Vtbl AudioClock2_Vtbl;
 170 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl;
 171 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl;
 172 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl;
 173
 174 typedef struct _SessionMgr {
 175     IAudioSessionManager2 IAudioSessionManager2_iface;
 176
 177     LONG ref;
 178
 179     IMMDevice *device;
 180 } SessionMgr;
 181
 182 static HANDLE g_timer_q;
 183
 184 static CRITICAL_SECTION g_sessions_lock;
 185 static CRITICAL_SECTION_DEBUG g_sessions_lock_debug =
 186 {
 187     0, 0, &g_sessions_lock,
 188     { &g_sessions_lock_debug.ProcessLocksList, &g_sessions_lock_debug.ProcessLocksList },
 189       0, 0, { (DWORD_PTR)(__FILE__ ": g_sessions_lock") }
 190 };
 191 static CRITICAL_SECTION g_sessions_lock = { &g_sessions_lock_debug, -1, 0, 0, 0, 0 };
 192 static struct list g_sessions = LIST_INIT(g_sessions);
 193
 194 static HRESULT AudioClock_GetPosition_nolock(ACImpl *This, UINT64 *pos,
 195         UINT64 *qpctime);
 196 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client);
 197 static HRESULT ca_setvol(ACImpl *This, UINT32 index);
 198
 199 static inline ACImpl *impl_from_IAudioClient(IAudioClient *iface)
 200 {
 201     return CONTAINING_RECORD(iface, ACImpl, IAudioClient_iface);
 202 }
 203
 204 static inline ACImpl *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
 205 {
 206     return CONTAINING_RECORD(iface, ACImpl, IAudioRenderClient_iface);
 207 }
 208
 209 static inline ACImpl *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
 210 {
 211     return CONTAINING_RECORD(iface, ACImpl, IAudioCaptureClient_iface);
 212 }
 213
 214 static inline AudioSessionWrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
 215 {
 216     return CONTAINING_RECORD(iface, AudioSessionWrapper, IAudioSessionControl2_iface);
 217 }
 218
 219 static inline AudioSessionWrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
 220 {
 221     return CONTAINING_RECORD(iface, AudioSessionWrapper, ISimpleAudioVolume_iface);
 222 }
 223
 224 static inline AudioSessionWrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
 225 {
 226     return CONTAINING_RECORD(iface, AudioSessionWrapper, IChannelAudioVolume_iface);
 227 }
 228
 229 static inline ACImpl *impl_from_IAudioClock(IAudioClock *iface)
 230 {
 231     return CONTAINING_RECORD(iface, ACImpl, IAudioClock_iface);
 232 }
 233
 234 static inline ACImpl *impl_from_IAudioClock2(IAudioClock2 *iface)
 235 {
 236     return CONTAINING_RECORD(iface, ACImpl, IAudioClock2_iface);
 237 }
 238
 239 static inline ACImpl *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
 240 {
 241     return CONTAINING_RECORD(iface, ACImpl, IAudioStreamVolume_iface);
 242 }
 243
 244 static inline SessionMgr *impl_from_IAudioSessionManager2(IAudioSessionManager2 *iface)
 245 {
 246     return CONTAINING_RECORD(iface, SessionMgr, IAudioSessionManager2_iface);
 247 }
 248
 249 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved)
 250 {
 251     switch (reason)
 252     {
 253     case DLL_PROCESS_ATTACH:
 254         g_timer_q = CreateTimerQueue();
 255         if(!g_timer_q)
 256             return FALSE;
 257         break;
 258
 259     case DLL_PROCESS_DETACH:
 260         DeleteCriticalSection(&g_sessions_lock);
 261         break;
 262     }
 263     return TRUE;
 264 }
 265
 266 /* From <dlls/mmdevapi/mmdevapi.h> */
 267 enum DriverPriority {
 268     Priority_Unavailable = 0,
 269     Priority_Low,
 270     Priority_Neutral,
 271     Priority_Preferred
 272 };
 273
 274 int WINAPI AUDDRV_GetPriority(void)
 275 {
 276     return Priority_Neutral;
 277 }
 278
 279 HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids,
 280         AudioDeviceID ***keys, UINT *num, UINT *def_index)
 281 {
 282     UInt32 devsize, size;
 283     AudioDeviceID *devices;
 284     AudioDeviceID default_id;
 285     AudioObjectPropertyAddress addr;
 286     OSStatus sc;
 287     int i, ndevices;
 288
 289     TRACE("%d %p %p %p\n", flow, ids, num, def_index);
 290
 291     addr.mScope = kAudioObjectPropertyScopeGlobal;
 292     addr.mElement = kAudioObjectPropertyElementMaster;
 293     if(flow == eRender)
 294         addr.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
 295     else if(flow == eCapture)
 296         addr.mSelector = kAudioHardwarePropertyDefaultInputDevice;
 297     else
 298         return E_INVALIDARG;
 299
 300     size = sizeof(default_id);
 301     sc = AudioObjectGetPropertyData(kAudioObjectSystemObject, &addr, 0,
 302             NULL, &size, &default_id);
 303     if(sc != noErr){
 304         WARN("Getting _DefaultInputDevice property failed: %lx\n", sc);
 305         default_id = -1;
 306     }
 307
 308     addr.mSelector = kAudioHardwarePropertyDevices;
 309     sc = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &addr, 0,
 310             NULL, &devsize);
 311     if(sc != noErr){
 312         WARN("Getting _Devices property size failed: %lx\n", sc);
 313         return E_FAIL;
 314     }
 315
 316     devices = HeapAlloc(GetProcessHeap(), 0, devsize);
 317     if(!devices)
 318         return E_OUTOFMEMORY;
 319
 320     sc = AudioObjectGetPropertyData(kAudioObjectSystemObject, &addr, 0, NULL,
 321             &devsize, devices);
 322     if(sc != noErr){
 323         WARN("Getting _Devices property failed: %lx\n", sc);
 324         HeapFree(GetProcessHeap(), 0, devices);
 325         return E_FAIL;
 326     }
 327
 328     ndevices = devsize / sizeof(AudioDeviceID);
 329
 330     *ids = HeapAlloc(GetProcessHeap(), 0, ndevices * sizeof(WCHAR *));
 331     if(!*ids){
 332         HeapFree(GetProcessHeap(), 0, devices);
 333         return E_OUTOFMEMORY;
 334     }
 335
 336     *keys = HeapAlloc(GetProcessHeap(), 0, ndevices * sizeof(AudioDeviceID *));
 337     if(!*ids){
 338         HeapFree(GetProcessHeap(), 0, *ids);
 339         HeapFree(GetProcessHeap(), 0, devices);
 340         return E_OUTOFMEMORY;
 341     }
 342
 343     *num = 0;
 344     *def_index = (UINT)-1;
 345     for(i = 0; i < ndevices; ++i){
 346         AudioBufferList *buffers;
 347         CFStringRef name;
 348         SIZE_T len;
 349         int j;
 350
 351         addr.mSelector = kAudioDevicePropertyStreamConfiguration;
 352         if(flow == eRender)
 353             addr.mScope = kAudioDevicePropertyScopeOutput;
 354         else
 355             addr.mScope = kAudioDevicePropertyScopeInput;
 356         addr.mElement = 0;
 357         sc = AudioObjectGetPropertyDataSize(devices[i], &addr, 0, NULL, &size);
 358         if(sc != noErr){
 359             WARN("Unable to get _StreamConfiguration property size for "
 360                     "device %lu: %lx\n", devices[i], sc);
 361             continue;
 362         }
 363
 364         buffers = HeapAlloc(GetProcessHeap(), 0, size);
 365         if(!buffers){
 366             HeapFree(GetProcessHeap(), 0, devices);
 367             for(j = 0; j < *num; ++j){
 368                 HeapFree(GetProcessHeap(), 0, (*ids)[j]);
 369                 HeapFree(GetProcessHeap(), 0, (*keys)[j]);
 370             }
 371             HeapFree(GetProcessHeap(), 0, *keys);
 372             HeapFree(GetProcessHeap(), 0, *ids);
 373             return E_OUTOFMEMORY;
 374         }
 375
 376         sc = AudioObjectGetPropertyData(devices[i], &addr, 0, NULL,
 377                 &size, buffers);
 378         if(sc != noErr){
 379             WARN("Unable to get _StreamConfiguration property for "
 380                     "device %lu: %lx\n", devices[i], sc);
 381             HeapFree(GetProcessHeap(), 0, buffers);
 382             continue;
 383         }
 384
 385         /* check that there's at least one channel in this device before
 386          * we claim it as usable */
 387         for(j = 0; j < buffers->mNumberBuffers; ++j)
 388             if(buffers->mBuffers[j].mNumberChannels > 0)
 389                 break;
 390         if(j >= buffers->mNumberBuffers){
 391             HeapFree(GetProcessHeap(), 0, buffers);
 392             continue;
 393         }
 394
 395         HeapFree(GetProcessHeap(), 0, buffers);
 396
 397         size = sizeof(name);
 398         addr.mSelector = kAudioObjectPropertyName;
 399         sc = AudioObjectGetPropertyData(devices[i], &addr, 0, NULL,
 400                 &size, &name);
 401         if(sc != noErr){
 402             WARN("Unable to get _Name property for device %lu: %lx\n",
 403                     devices[i], sc);
 404             continue;
 405         }
 406
 407         len = CFStringGetLength(name) + 1;
 408         (*ids)[*num] = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 409         if(!(*ids)[*num]){
 410             CFRelease(name);
 411             HeapFree(GetProcessHeap(), 0, devices);
 412             for(j = 0; j < *num; ++j){
 413                 HeapFree(GetProcessHeap(), 0, (*ids)[j]);
 414                 HeapFree(GetProcessHeap(), 0, (*keys)[j]);
 415             }
 416             HeapFree(GetProcessHeap(), 0, *ids);
 417             HeapFree(GetProcessHeap(), 0, *keys);
 418             return E_OUTOFMEMORY;
 419         }
 420         CFStringGetCharacters(name, CFRangeMake(0, len - 1), (UniChar*)(*ids)[*num]);
 421         ((*ids)[*num])[len - 1] = 0;
 422         CFRelease(name);
 423
 424         (*keys)[*num] = HeapAlloc(GetProcessHeap(), 0, sizeof(AudioDeviceID));
 425         if(!(*keys)[*num]){
 426             HeapFree(GetProcessHeap(), 0, devices);
 427             HeapFree(GetProcessHeap(), 0, (*ids)[*num]);
 428             for(j = 0; j < *num; ++j){
 429                 HeapFree(GetProcessHeap(), 0, (*ids)[j]);
 430                 HeapFree(GetProcessHeap(), 0, (*keys)[j]);
 431             }
 432             HeapFree(GetProcessHeap(), 0, *ids);
 433             HeapFree(GetProcessHeap(), 0, *keys);
 434             return E_OUTOFMEMORY;
 435         }
 436         *(*keys)[*num] = devices[i];
 437
 438         if(*def_index == (UINT)-1 && devices[i] == default_id)
 439             *def_index = *num;
 440
 441         TRACE("device %u: id %s key %u%s\n", *num, debugstr_w((*ids)[*num]),
 442               (unsigned int)*(*keys)[*num], (*def_index == *num) ? " (default)" : "");
 443
 444         (*num)++;
 445     }
 446
 447     if(*def_index == (UINT)-1)
 448         *def_index = 0;
 449
 450     HeapFree(GetProcessHeap(), 0, devices);
 451
 452     return S_OK;
 453 }
 454
 455 HRESULT WINAPI AUDDRV_GetAudioEndpoint(AudioDeviceID *adevid, IMMDevice *dev,
 456         EDataFlow dataflow, IAudioClient **out)
 457 {
 458     ACImpl *This;
 459
 460     TRACE("%u %p %d %p\n", (unsigned int)*adevid, dev, dataflow, out);
 461
 462     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACImpl));
 463     if(!This)
 464         return E_OUTOFMEMORY;
 465
 466     This->IAudioClient_iface.lpVtbl = &AudioClient_Vtbl;
 467     This->IAudioRenderClient_iface.lpVtbl = &AudioRenderClient_Vtbl;
 468     This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
 469     This->IAudioClock_iface.lpVtbl = &AudioClock_Vtbl;
 470     This->IAudioClock2_iface.lpVtbl = &AudioClock2_Vtbl;
 471     This->IAudioStreamVolume_iface.lpVtbl = &AudioStreamVolume_Vtbl;
 472
 473     This->dataflow = dataflow;
 474
 475     if(dataflow == eRender)
 476         This->scope = kAudioDevicePropertyScopeOutput;
 477     else if(dataflow == eCapture)
 478         This->scope = kAudioDevicePropertyScopeInput;
 479     else{
 480         HeapFree(GetProcessHeap(), 0, This);
 481         return E_INVALIDARG;
 482     }
 483
 484     This->lock = 0;
 485
 486     This->parent = dev;
 487     IMMDevice_AddRef(This->parent);
 488
 489     list_init(&This->avail_buffers);
 490     list_init(&This->queued_bufinfos);
 491
 492     This->adevid = *adevid;
 493
 494     *out = &This->IAudioClient_iface;
 495     IAudioClient_AddRef(&This->IAudioClient_iface);
 496
 497     return S_OK;
 498 }
 499
 500 /* current position from start of stream */
 501 #define BUFPOS_ABSOLUTE 1
 502 /* current position from start of this buffer */
 503 #define BUFPOS_RELATIVE 2
 504
 505 static UINT64 get_current_aqbuffer_position(ACImpl *This, int mode)
 506 {
 507     struct list *head;
 508     QueuedBufInfo *bufinfo;
 509     UINT64 ret;
 510
 511     head = list_head(&This->queued_bufinfos);
 512     if(!head){
 513         TRACE("No buffers queued\n");
 514         if(mode == BUFPOS_ABSOLUTE)
 515             return This->written_frames;
 516         return 0;
 517     }
 518     bufinfo = LIST_ENTRY(head, QueuedBufInfo, entry);
 519
 520     if(This->playing == StatePlaying){
 521         AudioTimeStamp tstamp;
 522         OSStatus sc;
 523
 524         /* AudioQueueGetCurrentTime() is brain damaged. The returned
 525          * mSampleTime member jumps backwards seemingly at random, so
 526          * we record the highest sampletime and use that during these
 527          * anomalies.
 528          *
 529          * It also behaves poorly when the queue is paused, jumping
 530          * forwards during the pause and backwards again after resuming.
 531          * So we record the sampletime when the queue is paused and use
 532          * that. */
 533         sc = AudioQueueGetCurrentTime(This->aqueue, NULL, &tstamp, NULL);
 534         if(sc != noErr){
 535             if(sc != kAudioQueueErr_InvalidRunState)
 536                 WARN("Unable to get current time: %lx\n", sc);
 537             return 0;
 538         }
 539
 540         if(!(tstamp.mFlags & kAudioTimeStampSampleTimeValid)){
 541             FIXME("SampleTime not valid: %lx\n", tstamp.mFlags);
 542             return 0;
 543         }
 544
 545         if(tstamp.mSampleTime > This->highest_sampletime)
 546             This->highest_sampletime = tstamp.mSampleTime;
 547     }
 548
 549     while(This->highest_sampletime > bufinfo->start_sampletime + bufinfo->len_frames){
 550         This->inbuf_frames -= bufinfo->len_frames;
 551         list_remove(&bufinfo->entry);
 552         HeapFree(GetProcessHeap(), 0, bufinfo);
 553
 554         head = list_head(&This->queued_bufinfos);
 555         if(!head){
 556             TRACE("No buffers queued\n");
 557             if(mode == BUFPOS_ABSOLUTE)
 558                 return This->written_frames;
 559             return 0;
 560         }
 561         bufinfo = LIST_ENTRY(head, QueuedBufInfo, entry);
 562     }
 563
 564     if(This->highest_sampletime < bufinfo->start_sampletime)
 565         ret = 0;
 566     else
 567         ret = This->highest_sampletime - bufinfo->start_sampletime;
 568
 569     if(mode == BUFPOS_ABSOLUTE)
 570         ret += bufinfo->start_pos;
 571
 572     TRACE("%llu frames (%s)\n", ret,
 573             mode == BUFPOS_ABSOLUTE ? "absolute" : "relative");
 574
 575     return ret;
 576 }
 577
 578 static HRESULT WINAPI AudioClient_QueryInterface(IAudioClient *iface,
 579         REFIID riid, void **ppv)
 580 {
 581     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 582
 583     if(!ppv)
 584         return E_POINTER;
 585     *ppv = NULL;
 586     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClient))
 587         *ppv = iface;
 588     if(*ppv){
 589         IUnknown_AddRef((IUnknown*)*ppv);
 590         return S_OK;
 591     }
 592     WARN("Unknown interface %s\n", debugstr_guid(riid));
 593     return E_NOINTERFACE;
 594 }
 595
 596 static ULONG WINAPI AudioClient_AddRef(IAudioClient *iface)
 597 {
 598     ACImpl *This = impl_from_IAudioClient(iface);
 599     ULONG ref;
 600     ref = InterlockedIncrement(&This->ref);
 601     TRACE("(%p) Refcount now %u\n", This, ref);
 602     return ref;
 603 }
 604
 605 static ULONG WINAPI AudioClient_Release(IAudioClient *iface)
 606 {
 607     ACImpl *This = impl_from_IAudioClient(iface);
 608     ULONG ref;
 609     ref = InterlockedDecrement(&This->ref);
 610     TRACE("(%p) Refcount now %u\n", This, ref);
 611     if(!ref){
 612         if(This->aqueue){
 613             AQBuffer *buf, *next;
 614             QueuedBufInfo *bufinfo, *bufinfo2;
 615
 616             if(This->public_buffer){
 617                 buf = This->public_buffer->mUserData;
 618                 list_add_tail(&This->avail_buffers, &buf->entry);
 619             }
 620
 621             IAudioClient_Stop(iface);
 622             AudioQueueStop(This->aqueue, 1);
 623
 624             /* Stopped synchronously, all buffers returned. */
 625             LIST_FOR_EACH_ENTRY_SAFE(buf, next, &This->avail_buffers, AQBuffer, entry){
 626                 AudioQueueFreeBuffer(This->aqueue, buf->buf);
 627                 HeapFree(GetProcessHeap(), 0, buf);
 628             }
 629
 630             LIST_FOR_EACH_ENTRY_SAFE(bufinfo, bufinfo2, &This->queued_bufinfos,
 631                     QueuedBufInfo, entry)
 632                 HeapFree(GetProcessHeap(), 0, bufinfo);
 633
 634             AudioQueueDispose(This->aqueue, 1);
 635         }
 636         if(This->session){
 637             EnterCriticalSection(&g_sessions_lock);
 638             list_remove(&This->entry);
 639             LeaveCriticalSection(&g_sessions_lock);
 640         }
 641         HeapFree(GetProcessHeap(), 0, This->vols);
 642         CoTaskMemFree(This->fmt);
 643         IMMDevice_Release(This->parent);
 644         HeapFree(GetProcessHeap(), 0, This);
 645     }
 646     return ref;
 647 }
 648
 649 static void dump_fmt(const WAVEFORMATEX *fmt)
 650 {
 651     TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
 652     switch(fmt->wFormatTag){
 653     case WAVE_FORMAT_PCM:
 654         TRACE("WAVE_FORMAT_PCM");
 655         break;
 656     case WAVE_FORMAT_IEEE_FLOAT:
 657         TRACE("WAVE_FORMAT_IEEE_FLOAT");
 658         break;
 659     case WAVE_FORMAT_EXTENSIBLE:
 660         TRACE("WAVE_FORMAT_EXTENSIBLE");
 661         break;
 662     default:
 663         TRACE("Unknown");
 664         break;
 665     }
 666     TRACE(")\n");
 667
 668     TRACE("nChannels: %u\n", fmt->nChannels);
 669     TRACE("nSamplesPerSec: %u\n", fmt->nSamplesPerSec);
 670     TRACE("nAvgBytesPerSec: %u\n", fmt->nAvgBytesPerSec);
 671     TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
 672     TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
 673     TRACE("cbSize: %u\n", fmt->cbSize);
 674
 675     if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
 676         WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
 677         TRACE("dwChannelMask: %08x\n", fmtex->dwChannelMask);
 678         TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
 679         TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
 680     }
 681 }
 682
 683 static DWORD get_channel_mask(unsigned int channels)
 684 {
 685     switch(channels){
 686     case 0:
 687         return 0;
 688     case 1:
 689         return KSAUDIO_SPEAKER_MONO;
 690     case 2:
 691         return KSAUDIO_SPEAKER_STEREO;
 692     case 3:
 693         return KSAUDIO_SPEAKER_STEREO | SPEAKER_LOW_FREQUENCY;
 694     case 4:
 695         return KSAUDIO_SPEAKER_QUAD;    /* not _SURROUND */
 696     case 5:
 697         return KSAUDIO_SPEAKER_QUAD | SPEAKER_LOW_FREQUENCY;
 698     case 6:
 699         return KSAUDIO_SPEAKER_5POINT1; /* not 5POINT1_SURROUND */
 700     case 7:
 701         return KSAUDIO_SPEAKER_5POINT1 | SPEAKER_BACK_CENTER;
 702     case 8:
 703         return KSAUDIO_SPEAKER_7POINT1_SURROUND; /* Vista deprecates 7POINT1 */
 704     }
 705     FIXME("Unknown speaker configuration: %u\n", channels);
 706     return 0;
 707 }
 708
 709 static WAVEFORMATEX *clone_format(const WAVEFORMATEX *fmt)
 710 {
 711     WAVEFORMATEX *ret;
 712     size_t size;
 713
 714     if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 715         size = sizeof(WAVEFORMATEXTENSIBLE);
 716     else
 717         size = sizeof(WAVEFORMATEX);
 718
 719     ret = CoTaskMemAlloc(size);
 720     if(!ret)
 721         return NULL;
 722
 723     memcpy(ret, fmt, size);
 724
 725     ret->cbSize = size - sizeof(WAVEFORMATEX);
 726
 727     return ret;
 728 }
 729
 730 static HRESULT ca_get_audiodesc(AudioStreamBasicDescription *desc,
 731         const WAVEFORMATEX *fmt)
 732 {
 733     const WAVEFORMATEXTENSIBLE *fmtex = (const WAVEFORMATEXTENSIBLE *)fmt;
 734
 735     desc->mFormatFlags = 0;
 736
 737     if(fmt->wFormatTag == WAVE_FORMAT_PCM ||
 738             (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 739              IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))){
 740         desc->mFormatID = kAudioFormatLinearPCM;
 741         if(fmt->wBitsPerSample > 8)
 742             desc->mFormatFlags = kAudioFormatFlagIsSignedInteger;
 743     }else if(fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
 744             (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 745              IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))){
 746         desc->mFormatID = kAudioFormatLinearPCM;
 747         desc->mFormatFlags = kAudioFormatFlagIsFloat;
 748     }else if(fmt->wFormatTag == WAVE_FORMAT_MULAW ||
 749             (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 750              IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_MULAW))){
 751         desc->mFormatID = kAudioFormatULaw;
 752     }else if(fmt->wFormatTag == WAVE_FORMAT_ALAW ||
 753             (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 754              IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_ALAW))){
 755         desc->mFormatID = kAudioFormatALaw;
 756     }else
 757         return AUDCLNT_E_UNSUPPORTED_FORMAT;
 758
 759     desc->mSampleRate = fmt->nSamplesPerSec;
 760     desc->mBytesPerPacket = fmt->nBlockAlign;
 761     desc->mFramesPerPacket = 1;
 762     desc->mBytesPerFrame = fmt->nBlockAlign;
 763     desc->mChannelsPerFrame = fmt->nChannels;
 764     desc->mBitsPerChannel = fmt->wBitsPerSample;
 765     desc->mReserved = 0;
 766
 767     return S_OK;
 768 }
 769
 770 static void ca_out_buffer_cb(void *user, AudioQueueRef aqueue,
 771         AudioQueueBufferRef buffer)
 772 {
 773     ACImpl *This = user;
 774     AQBuffer *buf = buffer->mUserData;
 775
 776     OSSpinLockLock(&This->lock);
 777     list_add_tail(&This->avail_buffers, &buf->entry);
 778     OSSpinLockUnlock(&This->lock);
 779 }
 780
 781 static void ca_in_buffer_cb(void *user, AudioQueueRef aqueue,
 782         AudioQueueBufferRef buffer, const AudioTimeStamp *start,
 783         UInt32 ndesc, const AudioStreamPacketDescription *descs)
 784 {
 785     ACImpl *This = user;
 786     AQBuffer *buf = buffer->mUserData;
 787
 788     OSSpinLockLock(&This->lock);
 789     list_add_tail(&This->avail_buffers, &buf->entry);
 790     This->inbuf_frames += buffer->mAudioDataByteSize / This->fmt->nBlockAlign;
 791     OSSpinLockUnlock(&This->lock);
 792 }
 793
 794 static HRESULT ca_setup_aqueue(AudioDeviceID did, EDataFlow flow,
 795         const WAVEFORMATEX *fmt, void *user, AudioQueueRef *aqueue)
 796 {
 797     AudioStreamBasicDescription desc;
 798     AudioObjectPropertyAddress addr;
 799     CFStringRef uid;
 800     OSStatus sc;
 801     HRESULT hr;
 802     UInt32 size;
 803
 804     addr.mScope = kAudioObjectPropertyScopeGlobal;
 805     addr.mElement = 0;
 806     addr.mSelector = kAudioDevicePropertyDeviceUID;
 807
 808     size = sizeof(uid);
 809     sc = AudioObjectGetPropertyData(did, &addr, 0, NULL, &size, &uid);
 810     if(sc != noErr){
 811         WARN("Unable to get _DeviceUID property: %lx\n", sc);
 812         return E_FAIL;
 813     }
 814
 815     hr = ca_get_audiodesc(&desc, fmt);
 816     if(FAILED(hr)){
 817         CFRelease(uid);
 818         return hr;
 819     }
 820
 821     if(flow == eRender)
 822         sc = AudioQueueNewOutput(&desc, ca_out_buffer_cb, user, NULL, NULL, 0,
 823                 aqueue);
 824     else if(flow == eCapture)
 825         sc = AudioQueueNewInput(&desc, ca_in_buffer_cb, user, NULL, NULL, 0,
 826                 aqueue);
 827     else{
 828         CFRelease(uid);
 829         return E_UNEXPECTED;
 830     }
 831     if(sc != noErr){
 832         WARN("Unable to create AudioQueue: %lx\n", sc);
 833         CFRelease(uid);
 834         return E_FAIL;
 835     }
 836
 837     sc = AudioQueueSetProperty(*aqueue, kAudioQueueProperty_CurrentDevice,
 838             &uid, sizeof(uid));
 839     if(sc != noErr){
 840         CFRelease(uid);
 841         return E_FAIL;
 842     }
 843
 844     CFRelease(uid);
 845
 846     return S_OK;
 847 }
 848
 849 static void session_init_vols(AudioSession *session, UINT channels)
 850 {
 851     if(session->channel_count < channels){
 852         UINT i;
 853
 854         if(session->channel_vols)
 855             session->channel_vols = HeapReAlloc(GetProcessHeap(), 0,
 856                     session->channel_vols, sizeof(float) * channels);
 857         else
 858             session->channel_vols = HeapAlloc(GetProcessHeap(), 0,
 859                     sizeof(float) * channels);
 860         if(!session->channel_vols)
 861             return;
 862
 863         for(i = session->channel_count; i < channels; ++i)
 864             session->channel_vols[i] = 1.f;
 865
 866         session->channel_count = channels;
 867     }
 868 }
 869
 870 static AudioSession *create_session(const GUID *guid, IMMDevice *device,
 871         UINT num_channels)
 872 {
 873     AudioSession *ret;
 874
 875     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioSession));
 876     if(!ret)
 877         return NULL;
 878
 879     memcpy(&ret->guid, guid, sizeof(GUID));
 880
 881     ret->device = device;
 882
 883     list_init(&ret->clients);
 884
 885     list_add_head(&g_sessions, &ret->entry);
 886
 887     InitializeCriticalSection(&ret->lock);
 888     ret->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": AudioSession.lock");
 889
 890     session_init_vols(ret, num_channels);
 891
 892     ret->master_vol = 1.f;
 893
 894     return ret;
 895 }
 896
 897 /* if channels == 0, then this will return or create a session with
 898  * matching dataflow and GUID. otherwise, channels must also match */
 899 static HRESULT get_audio_session(const GUID *sessionguid,
 900         IMMDevice *device, UINT channels, AudioSession **out)
 901 {
 902     AudioSession *session;
 903
 904     if(!sessionguid || IsEqualGUID(sessionguid, &GUID_NULL)){
 905         *out = create_session(&GUID_NULL, device, channels);
 906         if(!*out)
 907             return E_OUTOFMEMORY;
 908
 909         return S_OK;
 910     }
 911
 912     *out = NULL;
 913     LIST_FOR_EACH_ENTRY(session, &g_sessions, AudioSession, entry){
 914         if(session->device == device &&
 915                 IsEqualGUID(sessionguid, &session->guid)){
 916             session_init_vols(session, channels);
 917             *out = session;
 918             break;
 919         }
 920     }
 921
 922     if(!*out){
 923         *out = create_session(sessionguid, device, channels);
 924         if(!*out)
 925             return E_OUTOFMEMORY;
 926     }
 927
 928     return S_OK;
 929 }
 930
 931 static HRESULT WINAPI AudioClient_Initialize(IAudioClient *iface,
 932         AUDCLNT_SHAREMODE mode, DWORD flags, REFERENCE_TIME duration,
 933         REFERENCE_TIME period, const WAVEFORMATEX *fmt,
 934         const GUID *sessionguid)
 935 {
 936     ACImpl *This = impl_from_IAudioClient(iface);
 937     HRESULT hr;
 938     OSStatus sc;
 939     int i;
 940
 941     TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags,
 942           wine_dbgstr_longlong(duration), wine_dbgstr_longlong(period), fmt, debugstr_guid(sessionguid));
 943
 944     if(!fmt)
 945         return E_POINTER;
 946
 947     dump_fmt(fmt);
 948
 949     if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
 950         return AUDCLNT_E_NOT_INITIALIZED;
 951
 952     if(flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
 953                 AUDCLNT_STREAMFLAGS_LOOPBACK |
 954                 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
 955                 AUDCLNT_STREAMFLAGS_NOPERSIST |
 956                 AUDCLNT_STREAMFLAGS_RATEADJUST |
 957                 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
 958                 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
 959                 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED)){
 960         TRACE("Unknown flags: %08x\n", flags);
 961         return E_INVALIDARG;
 962     }
 963
 964     if(mode == AUDCLNT_SHAREMODE_SHARED){
 965         period = DefaultPeriod;
 966         if( duration < 3 * period)
 967             duration = 3 * period;
 968     }else{
 969         if(!period)
 970             period = DefaultPeriod; /* not minimum */
 971         if(period < MinimumPeriod || period > 5000000)
 972             return AUDCLNT_E_INVALID_DEVICE_PERIOD;
 973         if(duration > 20000000) /* the smaller the period, the lower this limit */
 974             return AUDCLNT_E_BUFFER_SIZE_ERROR;
 975         if(flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK){
 976             if(duration != period)
 977                 return AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL;
 978             FIXME("EXCLUSIVE mode with EVENTCALLBACK\n");
 979             return AUDCLNT_E_DEVICE_IN_USE;
 980         }else{
 981             if( duration < 8 * period)
 982                 duration = 8 * period; /* may grow above 2s */
 983         }
 984     }
 985
 986     OSSpinLockLock(&This->lock);
 987
 988     if(This->aqueue){
 989         OSSpinLockUnlock(&This->lock);
 990         return AUDCLNT_E_ALREADY_INITIALIZED;
 991     }
 992
 993     hr = ca_setup_aqueue(This->adevid, This->dataflow, fmt, This, &This->aqueue);
 994     if(FAILED(hr)){
 995         OSSpinLockUnlock(&This->lock);
 996         return hr;
 997     }
 998
 999     This->fmt = clone_format(fmt);
1000     if(!This->fmt){
1001         AudioQueueDispose(This->aqueue, 1);
1002         This->aqueue = NULL;
1003         OSSpinLockUnlock(&This->lock);
1004         return E_OUTOFMEMORY;
1005     }
1006
1007     This->period_ms = period / 10000;
1008
1009     This->bufsize_frames = MulDiv(duration, fmt->nSamplesPerSec, 10000000);
1010
1011     if(This->dataflow == eCapture){
1012         int i;
1013         UInt32 bsize = ceil((This->bufsize_frames / (double)CAPTURE_BUFFERS) *
1014                 This->fmt->nBlockAlign);
1015         for(i = 0; i < CAPTURE_BUFFERS; ++i){
1016             AQBuffer *buf;
1017
1018             buf = HeapAlloc(GetProcessHeap(), 0, sizeof(AQBuffer));
1019             if(!buf){
1020                 AudioQueueDispose(This->aqueue, 1);
1021                 This->aqueue = NULL;
1022                 CoTaskMemFree(This->fmt);
1023                 This->fmt = NULL;
1024                 OSSpinLockUnlock(&This->lock);
1025                 return E_OUTOFMEMORY;
1026             }
1027
1028             sc = AudioQueueAllocateBuffer(This->aqueue, bsize, &buf->buf);
1029             if(sc != noErr){
1030                 AudioQueueDispose(This->aqueue, 1);
1031                 This->aqueue = NULL;
1032                 CoTaskMemFree(This->fmt);
1033                 This->fmt = NULL;
1034                 OSSpinLockUnlock(&This->lock);
1035                 WARN("Couldn't allocate buffer: %lx\n", sc);
1036                 return E_FAIL;
1037             }
1038
1039             buf->buf->mUserData = buf;
1040
1041             sc = AudioQueueEnqueueBuffer(This->aqueue, buf->buf, 0, NULL);
1042             if(sc != noErr){
1043                 ERR("Couldn't enqueue buffer: %lx\n", sc);
1044                 break;
1045             }
1046         }
1047     }
1048
1049     This->vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
1050     if(!This->vols){
1051         AudioQueueDispose(This->aqueue, 1);
1052         This->aqueue = NULL;
1053         CoTaskMemFree(This->fmt);
1054         This->fmt = NULL;
1055         OSSpinLockUnlock(&This->lock);
1056         return E_OUTOFMEMORY;
1057     }
1058
1059     for(i = 0; i < fmt->nChannels; ++i)
1060         This->vols[i] = 1.f;
1061
1062     This->share = mode;
1063     This->flags = flags;
1064
1065     EnterCriticalSection(&g_sessions_lock);
1066
1067     hr = get_audio_session(sessionguid, This->parent, fmt->nChannels,
1068             &This->session);
1069     if(FAILED(hr)){
1070         LeaveCriticalSection(&g_sessions_lock);
1071         AudioQueueDispose(This->aqueue, 1);
1072         This->aqueue = NULL;
1073         CoTaskMemFree(This->fmt);
1074         This->fmt = NULL;
1075         HeapFree(GetProcessHeap(), 0, This->vols);
1076         This->vols = NULL;
1077         OSSpinLockUnlock(&This->lock);
1078         return E_INVALIDARG;
1079     }
1080
1081     list_add_tail(&This->session->clients, &This->entry);
1082
1083     LeaveCriticalSection(&g_sessions_lock);
1084
1085     ca_setvol(This, -1);
1086
1087     OSSpinLockUnlock(&This->lock);
1088
1089     return S_OK;
1090 }
1091
1092 static HRESULT WINAPI AudioClient_GetBufferSize(IAudioClient *iface,
1093         UINT32 *frames)
1094 {
1095     ACImpl *This = impl_from_IAudioClient(iface);
1096
1097     TRACE("(%p)->(%p)\n", This, frames);
1098
1099     if(!frames)
1100         return E_POINTER;
1101
1102     OSSpinLockLock(&This->lock);
1103
1104     if(!This->aqueue){
1105         OSSpinLockUnlock(&This->lock);
1106         return AUDCLNT_E_NOT_INITIALIZED;
1107     }
1108
1109     *frames = This->bufsize_frames;
1110
1111     OSSpinLockUnlock(&This->lock);
1112
1113     return S_OK;
1114 }
1115
1116 static HRESULT ca_get_max_stream_latency(ACImpl *This, UInt32 *max)
1117 {
1118     AudioObjectPropertyAddress addr;
1119     AudioStreamID *ids;
1120     UInt32 size;
1121     OSStatus sc;
1122     int nstreams, i;
1123
1124     addr.mScope = This->scope;
1125     addr.mElement = 0;
1126     addr.mSelector = kAudioDevicePropertyStreams;
1127
1128     sc = AudioObjectGetPropertyDataSize(This->adevid, &addr, 0, NULL,
1129             &size);
1130     if(sc != noErr){
1131         WARN("Unable to get size for _Streams property: %lx\n", sc);
1132         return E_FAIL;
1133     }
1134
1135     ids = HeapAlloc(GetProcessHeap(), 0, size);
1136     if(!ids)
1137         return E_OUTOFMEMORY;
1138
1139     sc = AudioObjectGetPropertyData(This->adevid, &addr, 0, NULL, &size, ids);
1140     if(sc != noErr){
1141         WARN("Unable to get _Streams property: %lx\n", sc);
1142         HeapFree(GetProcessHeap(), 0, ids);
1143         return E_FAIL;
1144     }
1145
1146     nstreams = size / sizeof(AudioStreamID);
1147     *max = 0;
1148
1149     addr.mSelector = kAudioStreamPropertyLatency;
1150     for(i = 0; i < nstreams; ++i){
1151         UInt32 latency;
1152
1153         size = sizeof(latency);
1154         sc = AudioObjectGetPropertyData(ids[i], &addr, 0, NULL,
1155                 &size, &latency);
1156         if(sc != noErr){
1157             WARN("Unable to get _Latency property: %lx\n", sc);
1158             continue;
1159         }
1160
1161         if(latency > *max)
1162             *max = latency;
1163     }
1164
1165     HeapFree(GetProcessHeap(), 0, ids);
1166
1167     return S_OK;
1168 }
1169
1170 static HRESULT WINAPI AudioClient_GetStreamLatency(IAudioClient *iface,
1171         REFERENCE_TIME *out)
1172 {
1173     ACImpl *This = impl_from_IAudioClient(iface);
1174     UInt32 latency, stream_latency, size;
1175     AudioObjectPropertyAddress addr;
1176     OSStatus sc;
1177     HRESULT hr;
1178
1179     TRACE("(%p)->(%p)\n", This, out);
1180
1181     if(!out)
1182         return E_POINTER;
1183
1184     OSSpinLockLock(&This->lock);
1185
1186     if(!This->aqueue){
1187         OSSpinLockUnlock(&This->lock);
1188         return AUDCLNT_E_NOT_INITIALIZED;
1189     }
1190
1191     addr.mScope = This->scope;
1192     addr.mSelector = kAudioDevicePropertyLatency;
1193     addr.mElement = 0;
1194
1195     size = sizeof(latency);
1196     sc = AudioObjectGetPropertyData(This->adevid, &addr, 0, NULL,
1197             &size, &latency);
1198     if(sc != noErr){
1199         WARN("Couldn't get _Latency property: %lx\n", sc);
1200         OSSpinLockUnlock(&This->lock);
1201         return E_FAIL;
1202     }
1203
1204     hr = ca_get_max_stream_latency(This, &stream_latency);
1205     if(FAILED(hr)){
1206         OSSpinLockUnlock(&This->lock);
1207         return hr;
1208     }
1209
1210     latency += stream_latency;
1211     /* pretend we process audio in Period chunks, so max latency includes
1212      * the period time */
1213     *out = MulDiv(latency, 10000000, This->fmt->nSamplesPerSec)
1214          + This->period_ms * 10000;
1215
1216     OSSpinLockUnlock(&This->lock);
1217
1218     return S_OK;
1219 }
1220
1221 static HRESULT AudioClient_GetCurrentPadding_nolock(ACImpl *This,
1222         UINT32 *numpad)
1223 {
1224     if(!This->aqueue)
1225         return AUDCLNT_E_NOT_INITIALIZED;
1226
1227     if(This->dataflow == eRender){
1228         UINT64 bufpos;
1229         bufpos = get_current_aqbuffer_position(This, BUFPOS_RELATIVE);
1230         *numpad = This->inbuf_frames - bufpos;
1231     }else
1232         *numpad = This->inbuf_frames;
1233
1234     return S_OK;
1235 }
1236
1237 static HRESULT WINAPI AudioClient_GetCurrentPadding(IAudioClient *iface,
1238         UINT32 *numpad)
1239 {
1240     ACImpl *This = impl_from_IAudioClient(iface);
1241     HRESULT hr;
1242
1243     TRACE("(%p)->(%p)\n", This, numpad);
1244
1245     if(!numpad)
1246         return E_POINTER;
1247
1248     OSSpinLockLock(&This->lock);
1249
1250     hr = AudioClient_GetCurrentPadding_nolock(This, numpad);
1251
1252     OSSpinLockUnlock(&This->lock);
1253
1254     return hr;
1255 }
1256
1257 static HRESULT WINAPI AudioClient_IsFormatSupported(IAudioClient *iface,
1258         AUDCLNT_SHAREMODE mode, const WAVEFORMATEX *pwfx,
1259         WAVEFORMATEX **outpwfx)
1260 {
1261     ACImpl *This = impl_from_IAudioClient(iface);
1262     WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)pwfx;
1263     AudioQueueRef aqueue;
1264     HRESULT hr;
1265
1266     TRACE("(%p)->(%x, %p, %p)\n", This, mode, pwfx, outpwfx);
1267
1268     if(!pwfx || (mode == AUDCLNT_SHAREMODE_SHARED && !outpwfx))
1269         return E_POINTER;
1270
1271     if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
1272         return E_INVALIDARG;
1273
1274     if(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1275             pwfx->cbSize < sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX))
1276         return E_INVALIDARG;
1277
1278     dump_fmt(pwfx);
1279
1280     if(outpwfx)
1281         *outpwfx = NULL;
1282
1283     if(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1284             fmtex->dwChannelMask != 0 &&
1285             fmtex->dwChannelMask != get_channel_mask(pwfx->nChannels))
1286         return AUDCLNT_E_UNSUPPORTED_FORMAT;
1287
1288     OSSpinLockLock(&This->lock);
1289
1290     hr = ca_setup_aqueue(This->adevid, This->dataflow, pwfx, NULL, &aqueue);
1291     if(SUCCEEDED(hr)){
1292         AudioQueueDispose(aqueue, 1);
1293         OSSpinLockUnlock(&This->lock);
1294         TRACE("returning %08x\n", S_OK);
1295         return S_OK;
1296     }
1297
1298     OSSpinLockUnlock(&This->lock);
1299
1300     TRACE("returning %08x\n", AUDCLNT_E_UNSUPPORTED_FORMAT);
1301     return AUDCLNT_E_UNSUPPORTED_FORMAT;
1302 }
1303
1304 static HRESULT WINAPI AudioClient_GetMixFormat(IAudioClient *iface,
1305         WAVEFORMATEX **pwfx)
1306 {
1307     ACImpl *This = impl_from_IAudioClient(iface);
1308     WAVEFORMATEXTENSIBLE *fmt;
1309     OSStatus sc;
1310     UInt32 size;
1311     Float64 rate;
1312     AudioBufferList *buffers;
1313     AudioObjectPropertyAddress addr;
1314     int i;
1315
1316     TRACE("(%p)->(%p)\n", This, pwfx);
1317
1318     if(!pwfx)
1319         return E_POINTER;
1320     *pwfx = NULL;
1321
1322     fmt = CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE));
1323     if(!fmt)
1324         return E_OUTOFMEMORY;
1325
1326     fmt->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
1327
1328     addr.mScope = This->scope;
1329     addr.mElement = 0;
1330     addr.mSelector = kAudioDevicePropertyStreamConfiguration;
1331
1332     sc = AudioObjectGetPropertyDataSize(This->adevid, &addr, 0, NULL, &size);
1333     if(sc != noErr){
1334         CoTaskMemFree(fmt);
1335         WARN("Unable to get size for _StreamConfiguration property: %lx\n", sc);
1336         return E_FAIL;
1337     }
1338
1339     buffers = HeapAlloc(GetProcessHeap(), 0, size);
1340     if(!buffers){
1341         CoTaskMemFree(fmt);
1342         return E_OUTOFMEMORY;
1343     }
1344
1345     sc = AudioObjectGetPropertyData(This->adevid, &addr, 0, NULL,
1346             &size, buffers);
1347     if(sc != noErr){
1348         CoTaskMemFree(fmt);
1349         HeapFree(GetProcessHeap(), 0, buffers);
1350         WARN("Unable to get _StreamConfiguration property: %lx\n", sc);
1351         return E_FAIL;
1352     }
1353
1354     fmt->Format.nChannels = 0;
1355     for(i = 0; i < buffers->mNumberBuffers; ++i)
1356         fmt->Format.nChannels += buffers->mBuffers[i].mNumberChannels;
1357
1358     HeapFree(GetProcessHeap(), 0, buffers);
1359
1360     fmt->dwChannelMask = get_channel_mask(fmt->Format.nChannels);
1361
1362     addr.mSelector = kAudioDevicePropertyNominalSampleRate;
1363     size = sizeof(Float64);
1364     sc = AudioObjectGetPropertyData(This->adevid, &addr, 0, NULL, &size, &rate);
1365     if(sc != noErr){
1366         CoTaskMemFree(fmt);
1367         WARN("Unable to get _NominalSampleRate property: %lx\n", sc);
1368         return E_FAIL;
1369     }
1370     fmt->Format.nSamplesPerSec = rate;
1371
1372     fmt->Format.wBitsPerSample = 32;
1373     fmt->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1374
1375     fmt->Format.nBlockAlign = (fmt->Format.wBitsPerSample *
1376             fmt->Format.nChannels) / 8;
1377     fmt->Format.nAvgBytesPerSec = fmt->Format.nSamplesPerSec *
1378         fmt->Format.nBlockAlign;
1379
1380     fmt->Samples.wValidBitsPerSample = fmt->Format.wBitsPerSample;
1381     fmt->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
1382
1383     *pwfx = (WAVEFORMATEX*)fmt;
1384     dump_fmt(*pwfx);
1385
1386     return S_OK;
1387 }
1388
1389 static HRESULT WINAPI AudioClient_GetDevicePeriod(IAudioClient *iface,
1390         REFERENCE_TIME *defperiod, REFERENCE_TIME *minperiod)
1391 {
1392     ACImpl *This = impl_from_IAudioClient(iface);
1393
1394     TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
1395
1396     if(!defperiod && !minperiod)
1397         return E_POINTER;
1398
1399     if(defperiod)
1400         *defperiod = DefaultPeriod;
1401     if(minperiod)
1402         *minperiod = MinimumPeriod;
1403
1404     return S_OK;
1405 }
1406
1407 void CALLBACK ca_period_cb(void *user, BOOLEAN timer)
1408 {
1409     ACImpl *This = user;
1410
1411     OSSpinLockLock(&This->lock);
1412     if(This->event)
1413         SetEvent(This->event);
1414     OSSpinLockUnlock(&This->lock);
1415 }
1416
1417 static HRESULT WINAPI AudioClient_Start(IAudioClient *iface)
1418 {
1419     ACImpl *This = impl_from_IAudioClient(iface);
1420     OSStatus sc;
1421
1422     TRACE("(%p)\n", This);
1423
1424     OSSpinLockLock(&This->lock);
1425
1426     if(!This->aqueue){
1427         OSSpinLockUnlock(&This->lock);
1428         return AUDCLNT_E_NOT_INITIALIZED;
1429     }
1430
1431     if(This->playing != StateStopped){
1432         OSSpinLockUnlock(&This->lock);
1433         return AUDCLNT_E_NOT_STOPPED;
1434     }
1435
1436     if((This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK) && !This->event){
1437         OSSpinLockUnlock(&This->lock);
1438         return AUDCLNT_E_EVENTHANDLE_NOT_SET;
1439     }
1440
1441     if(This->event)
1442         if(!CreateTimerQueueTimer(&This->timer, g_timer_q,
1443                     ca_period_cb, This, 0, This->period_ms, 0))
1444             ERR("Unable to create timer: %u\n", GetLastError());
1445
1446     This->playing = StateInTransition;
1447
1448     OSSpinLockUnlock(&This->lock);
1449
1450     sc = AudioQueueStart(This->aqueue, NULL);
1451     if(sc != noErr){
1452         WARN("Unable to start audio queue: %lx\n", sc);
1453         return E_FAIL;
1454     }
1455
1456     OSSpinLockLock(&This->lock);
1457
1458     This->playing = StatePlaying;
1459
1460     OSSpinLockUnlock(&This->lock);
1461
1462     return S_OK;
1463 }
1464
1465 static HRESULT WINAPI AudioClient_Stop(IAudioClient *iface)
1466 {
1467     ACImpl *This = impl_from_IAudioClient(iface);
1468     AudioTimeStamp tstamp;
1469     OSStatus sc;
1470
1471     TRACE("(%p)\n", This);
1472
1473     OSSpinLockLock(&This->lock);
1474
1475     if(!This->aqueue){
1476         OSSpinLockUnlock(&This->lock);
1477         return AUDCLNT_E_NOT_INITIALIZED;
1478     }
1479
1480     if(This->playing == StateStopped){
1481         OSSpinLockUnlock(&This->lock);
1482         return S_FALSE;
1483     }
1484
1485     if(This->playing == StateInTransition){
1486         OSSpinLockUnlock(&This->lock);
1487         return S_OK;
1488     }
1489
1490     if(This->timer && This->timer != INVALID_HANDLE_VALUE){
1491         DeleteTimerQueueTimer(g_timer_q, This->timer, INVALID_HANDLE_VALUE);
1492         This->timer = NULL;
1493     }
1494
1495     This->playing = StateInTransition;
1496
1497     sc = AudioQueueGetCurrentTime(This->aqueue, NULL, &tstamp, NULL);
1498     if(sc == noErr){
1499         if(tstamp.mFlags & kAudioTimeStampSampleTimeValid){
1500             if(tstamp.mSampleTime > This->highest_sampletime)
1501                 This->highest_sampletime = tstamp.mSampleTime;
1502         }else
1503             WARN("Returned tstamp mSampleTime not valid: %lx\n", tstamp.mFlags);
1504     }else
1505         WARN("GetCurrentTime failed: %lx\n", sc);
1506
1507     OSSpinLockUnlock(&This->lock);
1508
1509     sc = AudioQueueFlush(This->aqueue);
1510     if(sc != noErr)
1511         WARN("Unable to flush audio queue: %lx\n", sc);
1512
1513     sc = AudioQueuePause(This->aqueue);
1514     if(sc != noErr){
1515         WARN("Unable to pause audio queue: %lx\n", sc);
1516         return E_FAIL;
1517     }
1518
1519     OSSpinLockLock(&This->lock);
1520
1521     This->playing = StateStopped;
1522
1523     OSSpinLockUnlock(&This->lock);
1524
1525     return S_OK;
1526 }
1527
1528 static HRESULT WINAPI AudioClient_Reset(IAudioClient *iface)
1529 {
1530     ACImpl *This = impl_from_IAudioClient(iface);
1531     OSStatus sc;
1532     QueuedBufInfo *bufinfo, *bufinfo2;
1533
1534     TRACE("(%p)\n", This);
1535
1536     OSSpinLockLock(&This->lock);
1537
1538     if(!This->aqueue){
1539         OSSpinLockUnlock(&This->lock);
1540         return AUDCLNT_E_NOT_INITIALIZED;
1541     }
1542
1543     if(This->playing != StateStopped){
1544         OSSpinLockUnlock(&This->lock);
1545         return AUDCLNT_E_NOT_STOPPED;
1546     }
1547
1548     if(This->getbuf_last){
1549         OSSpinLockUnlock(&This->lock);
1550         return AUDCLNT_E_BUFFER_OPERATION_PENDING;
1551     }
1552
1553     This->written_frames = 0;
1554     This->inbuf_frames = 0;
1555
1556     LIST_FOR_EACH_ENTRY_SAFE(bufinfo, bufinfo2, &This->queued_bufinfos,
1557             QueuedBufInfo, entry){
1558         list_remove(&bufinfo->entry);
1559         HeapFree(GetProcessHeap(), 0, bufinfo);
1560     }
1561
1562     OSSpinLockUnlock(&This->lock);
1563
1564     sc = AudioQueueReset(This->aqueue);
1565     if(sc != noErr){
1566         WARN("Unable to reset audio queue: %lx\n", sc);
1567         return E_FAIL;
1568     }
1569
1570     return S_OK;
1571 }
1572
1573 static HRESULT WINAPI AudioClient_SetEventHandle(IAudioClient *iface,
1574         HANDLE event)
1575 {
1576     ACImpl *This = impl_from_IAudioClient(iface);
1577
1578     TRACE("(%p)->(%p)\n", This, event);
1579
1580     if(!event)
1581         return E_INVALIDARG;
1582
1583     OSSpinLockLock(&This->lock);
1584
1585     if(!This->aqueue){
1586         OSSpinLockUnlock(&This->lock);
1587         return AUDCLNT_E_NOT_INITIALIZED;
1588     }
1589
1590     if(!(This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK)){
1591         OSSpinLockUnlock(&This->lock);
1592         return AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED;
1593     }
1594
1595     This->event = event;
1596
1597     OSSpinLockUnlock(&This->lock);
1598
1599     return S_OK;
1600 }
1601
1602 static HRESULT WINAPI AudioClient_GetService(IAudioClient *iface, REFIID riid,
1603         void **ppv)
1604 {
1605     ACImpl *This = impl_from_IAudioClient(iface);
1606
1607     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1608
1609     if(!ppv)
1610         return E_POINTER;
1611     *ppv = NULL;
1612
1613     OSSpinLockLock(&This->lock);
1614
1615     if(!This->aqueue){
1616         OSSpinLockUnlock(&This->lock);
1617         return AUDCLNT_E_NOT_INITIALIZED;
1618     }
1619
1620     if(IsEqualIID(riid, &IID_IAudioRenderClient)){
1621         if(This->dataflow != eRender){
1622             OSSpinLockUnlock(&This->lock);
1623             return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1624         }
1625         IAudioRenderClient_AddRef(&This->IAudioRenderClient_iface);
1626         *ppv = &This->IAudioRenderClient_iface;
1627     }else if(IsEqualIID(riid, &IID_IAudioCaptureClient)){
1628         if(This->dataflow != eCapture){
1629             OSSpinLockUnlock(&This->lock);
1630             return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1631         }
1632         IAudioCaptureClient_AddRef(&This->IAudioCaptureClient_iface);
1633         *ppv = &This->IAudioCaptureClient_iface;
1634     }else if(IsEqualIID(riid, &IID_IAudioClock)){
1635         IAudioClock_AddRef(&This->IAudioClock_iface);
1636         *ppv = &This->IAudioClock_iface;
1637     }else if(IsEqualIID(riid, &IID_IAudioStreamVolume)){
1638         IAudioStreamVolume_AddRef(&This->IAudioStreamVolume_iface);
1639         *ppv = &This->IAudioStreamVolume_iface;
1640     }else if(IsEqualIID(riid, &IID_IAudioSessionControl)){
1641         if(!This->session_wrapper){
1642             This->session_wrapper = AudioSessionWrapper_Create(This);
1643             if(!This->session_wrapper){
1644                 OSSpinLockUnlock(&This->lock);
1645                 return E_OUTOFMEMORY;
1646             }
1647         }else
1648             IAudioSessionControl2_AddRef(&This->session_wrapper->IAudioSessionControl2_iface);
1649
1650         *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
1651     }else if(IsEqualIID(riid, &IID_IChannelAudioVolume)){
1652         if(!This->session_wrapper){
1653             This->session_wrapper = AudioSessionWrapper_Create(This);
1654             if(!This->session_wrapper){
1655                 OSSpinLockUnlock(&This->lock);
1656                 return E_OUTOFMEMORY;
1657             }
1658         }else
1659             IChannelAudioVolume_AddRef(&This->session_wrapper->IChannelAudioVolume_iface);
1660
1661         *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
1662     }else if(IsEqualIID(riid, &IID_ISimpleAudioVolume)){
1663         if(!This->session_wrapper){
1664             This->session_wrapper = AudioSessionWrapper_Create(This);
1665             if(!This->session_wrapper){
1666                 OSSpinLockUnlock(&This->lock);
1667                 return E_OUTOFMEMORY;
1668             }
1669         }else
1670             ISimpleAudioVolume_AddRef(&This->session_wrapper->ISimpleAudioVolume_iface);
1671
1672         *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
1673     }
1674
1675     if(*ppv){
1676         OSSpinLockUnlock(&This->lock);
1677         return S_OK;
1678     }
1679
1680     OSSpinLockUnlock(&This->lock);
1681
1682     FIXME("stub %s\n", debugstr_guid(riid));
1683     return E_NOINTERFACE;
1684 }
1685
1686 static const IAudioClientVtbl AudioClient_Vtbl =
1687 {
1688     AudioClient_QueryInterface,
1689     AudioClient_AddRef,
1690     AudioClient_Release,
1691     AudioClient_Initialize,
1692     AudioClient_GetBufferSize,
1693     AudioClient_GetStreamLatency,
1694     AudioClient_GetCurrentPadding,
1695     AudioClient_IsFormatSupported,
1696     AudioClient_GetMixFormat,
1697     AudioClient_GetDevicePeriod,
1698     AudioClient_Start,
1699     AudioClient_Stop,
1700     AudioClient_Reset,
1701     AudioClient_SetEventHandle,
1702     AudioClient_GetService
1703 };
1704
1705 static HRESULT WINAPI AudioRenderClient_QueryInterface(
1706         IAudioRenderClient *iface, REFIID riid, void **ppv)
1707 {
1708     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1709
1710     if(!ppv)
1711         return E_POINTER;
1712     *ppv = NULL;
1713
1714     if(IsEqualIID(riid, &IID_IUnknown) ||
1715             IsEqualIID(riid, &IID_IAudioRenderClient))
1716         *ppv = iface;
1717     if(*ppv){
1718         IUnknown_AddRef((IUnknown*)*ppv);
1719         return S_OK;
1720     }
1721
1722     WARN("Unknown interface %s\n", debugstr_guid(riid));
1723     return E_NOINTERFACE;
1724 }
1725
1726 static ULONG WINAPI AudioRenderClient_AddRef(IAudioRenderClient *iface)
1727 {
1728     ACImpl *This = impl_from_IAudioRenderClient(iface);
1729     return AudioClient_AddRef(&This->IAudioClient_iface);
1730 }
1731
1732 static ULONG WINAPI AudioRenderClient_Release(IAudioRenderClient *iface)
1733 {
1734     ACImpl *This = impl_from_IAudioRenderClient(iface);
1735     return AudioClient_Release(&This->IAudioClient_iface);
1736 }
1737
1738 static HRESULT WINAPI AudioRenderClient_GetBuffer(IAudioRenderClient *iface,
1739         UINT32 frames, BYTE **data)
1740 {
1741     ACImpl *This = impl_from_IAudioRenderClient(iface);
1742     AQBuffer *buf;
1743     UINT32 pad, bytes = frames * This->fmt->nBlockAlign;
1744     HRESULT hr;
1745     OSStatus sc;
1746
1747     TRACE("(%p)->(%u, %p)\n", This, frames, data);
1748
1749     if(!data)
1750         return E_POINTER;
1751     *data = NULL;
1752
1753     OSSpinLockLock(&This->lock);
1754
1755     if(This->getbuf_last){
1756         OSSpinLockUnlock(&This->lock);
1757         return AUDCLNT_E_OUT_OF_ORDER;
1758     }
1759
1760     if(!frames){
1761         OSSpinLockUnlock(&This->lock);
1762         return S_OK;
1763     }
1764
1765     hr = AudioClient_GetCurrentPadding_nolock(This, &pad);
1766     if(FAILED(hr)){
1767         OSSpinLockUnlock(&This->lock);
1768         return hr;
1769     }
1770
1771     if(pad + frames > This->bufsize_frames){
1772         OSSpinLockUnlock(&This->lock);
1773         return AUDCLNT_E_BUFFER_TOO_LARGE;
1774     }
1775
1776     LIST_FOR_EACH_ENTRY(buf, &This->avail_buffers, AQBuffer, entry){
1777         if(buf->buf->mAudioDataBytesCapacity >= bytes){
1778             This->public_buffer = buf->buf;
1779             list_remove(&buf->entry);
1780             break;
1781         }
1782     }
1783
1784     if(&buf->entry == &This->avail_buffers){
1785         sc = AudioQueueAllocateBuffer(This->aqueue, bytes,
1786                 &This->public_buffer);
1787         if(sc != noErr){
1788             OSSpinLockUnlock(&This->lock);
1789             WARN("Unable to allocate buffer: %lx\n", sc);
1790             return E_FAIL;
1791         }
1792         buf = HeapAlloc(GetProcessHeap(), 0, sizeof(AQBuffer));
1793         if(!buf){
1794             AudioQueueFreeBuffer(This->aqueue, This->public_buffer);
1795             This->public_buffer = NULL;
1796             OSSpinLockUnlock(&This->lock);
1797             return E_OUTOFMEMORY;
1798         }
1799         buf->buf = This->public_buffer;
1800         This->public_buffer->mUserData = buf;
1801     }
1802
1803     *data = This->public_buffer->mAudioData;
1804
1805     This->getbuf_last = frames;
1806
1807     OSSpinLockUnlock(&This->lock);
1808
1809     return S_OK;
1810 }
1811
1812 static HRESULT WINAPI AudioRenderClient_ReleaseBuffer(
1813         IAudioRenderClient *iface, UINT32 frames, DWORD flags)
1814 {
1815     ACImpl *This = impl_from_IAudioRenderClient(iface);
1816     AudioTimeStamp start_time;
1817     OSStatus sc;
1818
1819     TRACE("(%p)->(%u, %x)\n", This, frames, flags);
1820
1821     OSSpinLockLock(&This->lock);
1822
1823     if(!frames){
1824         This->getbuf_last = 0;
1825         if(This->public_buffer){
1826             AQBuffer *buf = This->public_buffer->mUserData;
1827             list_add_tail(&This->avail_buffers, &buf->entry);
1828             This->public_buffer = NULL;
1829         }
1830         OSSpinLockUnlock(&This->lock);
1831         return S_OK;
1832     }
1833
1834     if(!This->getbuf_last){
1835         OSSpinLockUnlock(&This->lock);
1836         return AUDCLNT_E_OUT_OF_ORDER;
1837     }
1838
1839     if(frames > This->getbuf_last){
1840         OSSpinLockUnlock(&This->lock);
1841         return AUDCLNT_E_INVALID_SIZE;
1842     }
1843
1844     if(flags & AUDCLNT_BUFFERFLAGS_SILENT){
1845         WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)This->fmt;
1846         if((This->fmt->wFormatTag == WAVE_FORMAT_PCM ||
1847                 (This->fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1848                  IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) &&
1849                 This->fmt->wBitsPerSample == 8)
1850             memset(This->public_buffer->mAudioData, 128,
1851                     frames * This->fmt->nBlockAlign);
1852         else
1853             memset(This->public_buffer->mAudioData, 0,
1854                     frames * This->fmt->nBlockAlign);
1855     }
1856
1857     This->public_buffer->mAudioDataByteSize = frames * This->fmt->nBlockAlign;
1858
1859     sc = AudioQueueEnqueueBufferWithParameters(This->aqueue,
1860             This->public_buffer, 0, NULL, 0, 0, 0, NULL, NULL, &start_time);
1861     if(sc != noErr){
1862         OSSpinLockUnlock(&This->lock);
1863         WARN("Unable to enqueue buffer: %lx\n", sc);
1864         return E_FAIL;
1865     }
1866
1867     if(start_time.mFlags & kAudioTimeStampSampleTimeValid){
1868         QueuedBufInfo *bufinfo;
1869
1870         bufinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*bufinfo));
1871         bufinfo->start_sampletime = start_time.mSampleTime;
1872         bufinfo->start_pos = This->written_frames;
1873         bufinfo->len_frames = frames;
1874
1875         list_add_tail(&This->queued_bufinfos, &bufinfo->entry);
1876     }else
1877         WARN("Start time didn't contain valid SampleTime member\n");
1878
1879     if(This->playing == StateStopped)
1880         AudioQueuePrime(This->aqueue, 0, NULL);
1881
1882     This->public_buffer = NULL;
1883     This->getbuf_last = 0;
1884     This->written_frames += frames;
1885     This->inbuf_frames += frames;
1886
1887     OSSpinLockUnlock(&This->lock);
1888
1889     return S_OK;
1890 }
1891
1892 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
1893     AudioRenderClient_QueryInterface,
1894     AudioRenderClient_AddRef,
1895     AudioRenderClient_Release,
1896     AudioRenderClient_GetBuffer,
1897     AudioRenderClient_ReleaseBuffer
1898 };
1899
1900 static HRESULT WINAPI AudioCaptureClient_QueryInterface(
1901         IAudioCaptureClient *iface, REFIID riid, void **ppv)
1902 {
1903     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1904
1905     if(!ppv)
1906         return E_POINTER;
1907     *ppv = NULL;
1908
1909     if(IsEqualIID(riid, &IID_IUnknown) ||
1910             IsEqualIID(riid, &IID_IAudioCaptureClient))
1911         *ppv = iface;
1912     if(*ppv){
1913         IUnknown_AddRef((IUnknown*)*ppv);
1914         return S_OK;
1915     }
1916
1917     WARN("Unknown interface %s\n", debugstr_guid(riid));
1918     return E_NOINTERFACE;
1919 }
1920
1921 static ULONG WINAPI AudioCaptureClient_AddRef(IAudioCaptureClient *iface)
1922 {
1923     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1924     return IAudioClient_AddRef(&This->IAudioClient_iface);
1925 }
1926
1927 static ULONG WINAPI AudioCaptureClient_Release(IAudioCaptureClient *iface)
1928 {
1929     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1930     return IAudioClient_Release(&This->IAudioClient_iface);
1931 }
1932
1933 static HRESULT AudioCaptureClient_GetNextPacket(ACImpl *This, UINT32 *frames)
1934 {
1935     OSStatus sc;
1936     for(;;){
1937         if(!This->public_buffer){
1938             struct list *head = list_head(&This->avail_buffers);
1939             AQBuffer *buf;
1940
1941             if(!head){
1942                 *frames = 0;
1943                 return S_OK;
1944             }
1945             buf = LIST_ENTRY(head, AQBuffer, entry);
1946             This->public_buffer = buf->buf;
1947             list_remove(&buf->entry);
1948         }
1949         *frames = This->public_buffer->mAudioDataByteSize / This->fmt->nBlockAlign;
1950         if(*frames)
1951             return S_OK;
1952         WARN("empty packet\n");
1953         /* fixme: for reasons not yet understood, the initially submitted
1954          * packets are returned with 0 bytes.  Resubmit them. */
1955         sc = AudioQueueEnqueueBuffer(This->aqueue, This->public_buffer, 0, NULL);
1956         if(sc != noErr){
1957             ERR("Unable to enqueue buffer: %lx\n", sc);
1958             /* Release will free This->public_buffer */
1959             return AUDCLNT_E_DEVICE_INVALIDATED;
1960         }else
1961             This->public_buffer = NULL;
1962     }
1963 }
1964
1965 static HRESULT WINAPI AudioCaptureClient_GetBuffer(IAudioCaptureClient *iface,
1966         BYTE **data, UINT32 *frames, DWORD *flags, UINT64 *devpos,
1967         UINT64 *qpcpos)
1968 {
1969     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1970     HRESULT hr;
1971
1972     TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags,
1973             devpos, qpcpos);
1974
1975     if(!data || !frames || !flags)
1976         return E_POINTER;
1977
1978     OSSpinLockLock(&This->lock);
1979
1980     if(This->getbuf_last){
1981         OSSpinLockUnlock(&This->lock);
1982         return AUDCLNT_E_OUT_OF_ORDER;
1983     }
1984
1985     hr = AudioCaptureClient_GetNextPacket(This, frames);
1986     if(FAILED(hr)){
1987         OSSpinLockUnlock(&This->lock);
1988         return hr;
1989     }
1990
1991     if((This->getbuf_last = *frames)){
1992         UINT64 pos;
1993         *flags = 0;
1994         *data = This->public_buffer->mAudioData;
1995
1996         if(devpos)
1997             *devpos = This->written_frames;
1998         if(qpcpos) /* fixme: qpc of recording time */
1999             AudioClock_GetPosition_nolock(This, &pos, qpcpos);
2000     }
2001     OSSpinLockUnlock(&This->lock);
2002
2003     return *frames ? S_OK : AUDCLNT_S_BUFFER_EMPTY;
2004 }
2005
2006 static HRESULT WINAPI AudioCaptureClient_ReleaseBuffer(
2007         IAudioCaptureClient *iface, UINT32 done)
2008 {
2009     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2010     OSStatus sc;
2011
2012     TRACE("(%p)->(%u)\n", This, done);
2013
2014     OSSpinLockLock(&This->lock);
2015
2016     if(!done){
2017         This->getbuf_last = 0;
2018         OSSpinLockUnlock(&This->lock);
2019         return S_OK;
2020     }
2021
2022     if(!This->getbuf_last){
2023         OSSpinLockUnlock(&This->lock);
2024         return AUDCLNT_E_OUT_OF_ORDER;
2025     }
2026
2027     if(This->getbuf_last != done){
2028         OSSpinLockUnlock(&This->lock);
2029         return AUDCLNT_E_INVALID_SIZE;
2030     }
2031
2032     This->written_frames += done;
2033     This->inbuf_frames -= done;
2034     This->getbuf_last = 0;
2035
2036     sc = AudioQueueEnqueueBuffer(This->aqueue, This->public_buffer, 0, NULL);
2037     if(sc != noErr){
2038         OSSpinLockUnlock(&This->lock);
2039         /* fixme: can't zero public_buffer or we lose memory, but then
2040          * GetBuffer will see that packet again and again. */
2041         ERR("Unable to enqueue buffer: %lx\n", sc);
2042         return AUDCLNT_E_DEVICE_INVALIDATED;
2043     }
2044     This->public_buffer = NULL;
2045
2046     OSSpinLockUnlock(&This->lock);
2047
2048     return S_OK;
2049 }
2050
2051 static HRESULT WINAPI AudioCaptureClient_GetNextPacketSize(
2052         IAudioCaptureClient *iface, UINT32 *frames)
2053 {
2054     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2055     HRESULT hr;
2056
2057     TRACE("(%p)->(%p)\n", This, frames);
2058
2059     if(!frames)
2060         return E_POINTER;
2061
2062     OSSpinLockLock(&This->lock);
2063
2064     hr = AudioCaptureClient_GetNextPacket(This, frames);
2065
2066     OSSpinLockUnlock(&This->lock);
2067
2068     return hr;
2069 }
2070
2071 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
2072 {
2073     AudioCaptureClient_QueryInterface,
2074     AudioCaptureClient_AddRef,
2075     AudioCaptureClient_Release,
2076     AudioCaptureClient_GetBuffer,
2077     AudioCaptureClient_ReleaseBuffer,
2078     AudioCaptureClient_GetNextPacketSize
2079 };
2080
2081 static HRESULT WINAPI AudioClock_QueryInterface(IAudioClock *iface,
2082         REFIID riid, void **ppv)
2083 {
2084     ACImpl *This = impl_from_IAudioClock(iface);
2085
2086     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2087
2088     if(!ppv)
2089         return E_POINTER;
2090     *ppv = NULL;
2091
2092     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClock))
2093         *ppv = iface;
2094     else if(IsEqualIID(riid, &IID_IAudioClock2))
2095         *ppv = &This->IAudioClock2_iface;
2096     if(*ppv){
2097         IUnknown_AddRef((IUnknown*)*ppv);
2098         return S_OK;
2099     }
2100
2101     WARN("Unknown interface %s\n", debugstr_guid(riid));
2102     return E_NOINTERFACE;
2103 }
2104
2105 static ULONG WINAPI AudioClock_AddRef(IAudioClock *iface)
2106 {
2107     ACImpl *This = impl_from_IAudioClock(iface);
2108     return IAudioClient_AddRef(&This->IAudioClient_iface);
2109 }
2110
2111 static ULONG WINAPI AudioClock_Release(IAudioClock *iface)
2112 {
2113     ACImpl *This = impl_from_IAudioClock(iface);
2114     return IAudioClient_Release(&This->IAudioClient_iface);
2115 }
2116
2117 static HRESULT WINAPI AudioClock_GetFrequency(IAudioClock *iface, UINT64 *freq)
2118 {
2119     ACImpl *This = impl_from_IAudioClock(iface);
2120
2121     TRACE("(%p)->(%p)\n", This, freq);
2122
2123     *freq = This->fmt->nSamplesPerSec;
2124
2125     return S_OK;
2126 }
2127
2128 static HRESULT AudioClock_GetPosition_nolock(ACImpl *This,
2129         UINT64 *pos, UINT64 *qpctime)
2130 {
2131     if(This->dataflow == eRender)
2132         *pos = get_current_aqbuffer_position(This, BUFPOS_ABSOLUTE);
2133     else
2134         *pos = This->inbuf_frames + This->written_frames;
2135
2136     if(qpctime){
2137         LARGE_INTEGER stamp, freq;
2138         QueryPerformanceCounter(&stamp);
2139         QueryPerformanceFrequency(&freq);
2140         *qpctime = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
2141     }
2142
2143     return S_OK;
2144 }
2145
2146 static HRESULT WINAPI AudioClock_GetPosition(IAudioClock *iface, UINT64 *pos,
2147         UINT64 *qpctime)
2148 {
2149     ACImpl *This = impl_from_IAudioClock(iface);
2150     HRESULT hr;
2151
2152     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
2153
2154     if(!pos)
2155         return E_POINTER;
2156
2157     OSSpinLockLock(&This->lock);
2158
2159     hr = AudioClock_GetPosition_nolock(This, pos, qpctime);
2160
2161     OSSpinLockUnlock(&This->lock);
2162
2163     return hr;
2164 }
2165
2166 static HRESULT WINAPI AudioClock_GetCharacteristics(IAudioClock *iface,
2167         DWORD *chars)
2168 {
2169     ACImpl *This = impl_from_IAudioClock(iface);
2170
2171     TRACE("(%p)->(%p)\n", This, chars);
2172
2173     if(!chars)
2174         return E_POINTER;
2175
2176     *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
2177
2178     return S_OK;
2179 }
2180
2181 static const IAudioClockVtbl AudioClock_Vtbl =
2182 {
2183     AudioClock_QueryInterface,
2184     AudioClock_AddRef,
2185     AudioClock_Release,
2186     AudioClock_GetFrequency,
2187     AudioClock_GetPosition,
2188     AudioClock_GetCharacteristics
2189 };
2190
2191 static HRESULT WINAPI AudioClock2_QueryInterface(IAudioClock2 *iface,
2192         REFIID riid, void **ppv)
2193 {
2194     ACImpl *This = impl_from_IAudioClock2(iface);
2195     return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
2196 }
2197
2198 static ULONG WINAPI AudioClock2_AddRef(IAudioClock2 *iface)
2199 {
2200     ACImpl *This = impl_from_IAudioClock2(iface);
2201     return IAudioClient_AddRef(&This->IAudioClient_iface);
2202 }
2203
2204 static ULONG WINAPI AudioClock2_Release(IAudioClock2 *iface)
2205 {
2206     ACImpl *This = impl_from_IAudioClock2(iface);
2207     return IAudioClient_Release(&This->IAudioClient_iface);
2208 }
2209
2210 static HRESULT WINAPI AudioClock2_GetDevicePosition(IAudioClock2 *iface,
2211         UINT64 *pos, UINT64 *qpctime)
2212 {
2213     ACImpl *This = impl_from_IAudioClock2(iface);
2214
2215     FIXME("(%p)->(%p, %p)\n", This, pos, qpctime);
2216
2217     return E_NOTIMPL;
2218 }
2219
2220 static const IAudioClock2Vtbl AudioClock2_Vtbl =
2221 {
2222     AudioClock2_QueryInterface,
2223     AudioClock2_AddRef,
2224     AudioClock2_Release,
2225     AudioClock2_GetDevicePosition
2226 };
2227
2228 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client)
2229 {
2230     AudioSessionWrapper *ret;
2231
2232     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2233             sizeof(AudioSessionWrapper));
2234     if(!ret)
2235         return NULL;
2236
2237     ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
2238     ret->ISimpleAudioVolume_iface.lpVtbl = &SimpleAudioVolume_Vtbl;
2239     ret->IChannelAudioVolume_iface.lpVtbl = &ChannelAudioVolume_Vtbl;
2240
2241     ret->ref = 1;
2242
2243     ret->client = client;
2244     if(client){
2245         ret->session = client->session;
2246         AudioClient_AddRef(&client->IAudioClient_iface);
2247     }
2248
2249     return ret;
2250 }
2251
2252 static HRESULT WINAPI AudioSessionControl_QueryInterface(
2253         IAudioSessionControl2 *iface, REFIID riid, void **ppv)
2254 {
2255     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2256
2257     if(!ppv)
2258         return E_POINTER;
2259     *ppv = NULL;
2260
2261     if(IsEqualIID(riid, &IID_IUnknown) ||
2262             IsEqualIID(riid, &IID_IAudioSessionControl) ||
2263             IsEqualIID(riid, &IID_IAudioSessionControl2))
2264         *ppv = iface;
2265     if(*ppv){
2266         IUnknown_AddRef((IUnknown*)*ppv);
2267         return S_OK;
2268     }
2269
2270     WARN("Unknown interface %s\n", debugstr_guid(riid));
2271     return E_NOINTERFACE;
2272 }
2273
2274 static ULONG WINAPI AudioSessionControl_AddRef(IAudioSessionControl2 *iface)
2275 {
2276     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2277     ULONG ref;
2278     ref = InterlockedIncrement(&This->ref);
2279     TRACE("(%p) Refcount now %u\n", This, ref);
2280     return ref;
2281 }
2282
2283 static ULONG WINAPI AudioSessionControl_Release(IAudioSessionControl2 *iface)
2284 {
2285     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2286     ULONG ref;
2287     ref = InterlockedDecrement(&This->ref);
2288     TRACE("(%p) Refcount now %u\n", This, ref);
2289     if(!ref){
2290         if(This->client){
2291             OSSpinLockLock(&This->client->lock);
2292             This->client->session_wrapper = NULL;
2293             OSSpinLockUnlock(&This->client->lock);
2294             AudioClient_Release(&This->client->IAudioClient_iface);
2295         }
2296         HeapFree(GetProcessHeap(), 0, This);
2297     }
2298     return ref;
2299 }
2300
2301 static HRESULT WINAPI AudioSessionControl_GetState(IAudioSessionControl2 *iface,
2302         AudioSessionState *state)
2303 {
2304     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2305     ACImpl *client;
2306
2307     TRACE("(%p)->(%p)\n", This, state);
2308
2309     if(!state)
2310         return NULL_PTR_ERR;
2311
2312     EnterCriticalSection(&g_sessions_lock);
2313
2314     if(list_empty(&This->session->clients)){
2315         *state = AudioSessionStateExpired;
2316         LeaveCriticalSection(&g_sessions_lock);
2317         return S_OK;
2318     }
2319
2320     LIST_FOR_EACH_ENTRY(client, &This->session->clients, ACImpl, entry){
2321         OSSpinLockLock(&client->lock);
2322         if(client->playing == StatePlaying ||
2323                 client->playing == StateInTransition){
2324             *state = AudioSessionStateActive;
2325             OSSpinLockUnlock(&client->lock);
2326             LeaveCriticalSection(&g_sessions_lock);
2327             return S_OK;
2328         }
2329         OSSpinLockUnlock(&client->lock);
2330     }
2331
2332     LeaveCriticalSection(&g_sessions_lock);
2333
2334     *state = AudioSessionStateInactive;
2335
2336     return S_OK;
2337 }
2338
2339 static HRESULT WINAPI AudioSessionControl_GetDisplayName(
2340         IAudioSessionControl2 *iface, WCHAR **name)
2341 {
2342     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2343
2344     FIXME("(%p)->(%p) - stub\n", This, name);
2345
2346     return E_NOTIMPL;
2347 }
2348
2349 static HRESULT WINAPI AudioSessionControl_SetDisplayName(
2350         IAudioSessionControl2 *iface, const WCHAR *name, const GUID *session)
2351 {
2352     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2353
2354     FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
2355
2356     return E_NOTIMPL;
2357 }
2358
2359 static HRESULT WINAPI AudioSessionControl_GetIconPath(
2360         IAudioSessionControl2 *iface, WCHAR **path)
2361 {
2362     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2363
2364     FIXME("(%p)->(%p) - stub\n", This, path);
2365
2366     return E_NOTIMPL;
2367 }
2368
2369 static HRESULT WINAPI AudioSessionControl_SetIconPath(
2370         IAudioSessionControl2 *iface, const WCHAR *path, const GUID *session)
2371 {
2372     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2373
2374     FIXME("(%p)->(%p, %s) - stub\n", This, path, debugstr_guid(session));
2375
2376     return E_NOTIMPL;
2377 }
2378
2379 static HRESULT WINAPI AudioSessionControl_GetGroupingParam(
2380         IAudioSessionControl2 *iface, GUID *group)
2381 {
2382     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2383
2384     FIXME("(%p)->(%p) - stub\n", This, group);
2385
2386     return E_NOTIMPL;
2387 }
2388
2389 static HRESULT WINAPI AudioSessionControl_SetGroupingParam(
2390         IAudioSessionControl2 *iface, const GUID *group, const GUID *session)
2391 {
2392     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2393
2394     FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group),
2395             debugstr_guid(session));
2396
2397     return E_NOTIMPL;
2398 }
2399
2400 static HRESULT WINAPI AudioSessionControl_RegisterAudioSessionNotification(
2401         IAudioSessionControl2 *iface, IAudioSessionEvents *events)
2402 {
2403     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2404
2405     FIXME("(%p)->(%p) - stub\n", This, events);
2406
2407     return S_OK;
2408 }
2409
2410 static HRESULT WINAPI AudioSessionControl_UnregisterAudioSessionNotification(
2411         IAudioSessionControl2 *iface, IAudioSessionEvents *events)
2412 {
2413     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2414
2415     FIXME("(%p)->(%p) - stub\n", This, events);
2416
2417     return S_OK;
2418 }
2419
2420 static HRESULT WINAPI AudioSessionControl_GetSessionIdentifier(
2421         IAudioSessionControl2 *iface, WCHAR **id)
2422 {
2423     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2424
2425     FIXME("(%p)->(%p) - stub\n", This, id);
2426
2427     return E_NOTIMPL;
2428 }
2429
2430 static HRESULT WINAPI AudioSessionControl_GetSessionInstanceIdentifier(
2431         IAudioSessionControl2 *iface, WCHAR **id)
2432 {
2433     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2434
2435     FIXME("(%p)->(%p) - stub\n", This, id);
2436
2437     return E_NOTIMPL;
2438 }
2439
2440 static HRESULT WINAPI AudioSessionControl_GetProcessId(
2441         IAudioSessionControl2 *iface, DWORD *pid)
2442 {
2443     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2444
2445     TRACE("(%p)->(%p)\n", This, pid);
2446
2447     if(!pid)
2448         return E_POINTER;
2449
2450     *pid = GetCurrentProcessId();
2451
2452     return S_OK;
2453 }
2454
2455 static HRESULT WINAPI AudioSessionControl_IsSystemSoundsSession(
2456         IAudioSessionControl2 *iface)
2457 {
2458     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2459
2460     TRACE("(%p)\n", This);
2461
2462     return S_FALSE;
2463 }
2464
2465 static HRESULT WINAPI AudioSessionControl_SetDuckingPreference(
2466         IAudioSessionControl2 *iface, BOOL optout)
2467 {
2468     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2469
2470     TRACE("(%p)->(%d)\n", This, optout);
2471
2472     return S_OK;
2473 }
2474
2475 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
2476 {
2477     AudioSessionControl_QueryInterface,
2478     AudioSessionControl_AddRef,
2479     AudioSessionControl_Release,
2480     AudioSessionControl_GetState,
2481     AudioSessionControl_GetDisplayName,
2482     AudioSessionControl_SetDisplayName,
2483     AudioSessionControl_GetIconPath,
2484     AudioSessionControl_SetIconPath,
2485     AudioSessionControl_GetGroupingParam,
2486     AudioSessionControl_SetGroupingParam,
2487     AudioSessionControl_RegisterAudioSessionNotification,
2488     AudioSessionControl_UnregisterAudioSessionNotification,
2489     AudioSessionControl_GetSessionIdentifier,
2490     AudioSessionControl_GetSessionInstanceIdentifier,
2491     AudioSessionControl_GetProcessId,
2492     AudioSessionControl_IsSystemSoundsSession,
2493     AudioSessionControl_SetDuckingPreference
2494 };
2495
2496 /* index == -1 means set all channels, otherwise sets only the given channel */
2497 static HRESULT ca_setvol(ACImpl *This, UINT32 index)
2498 {
2499     float level;
2500     OSStatus sc;
2501
2502     if(index == (UINT32)-1){
2503         HRESULT ret = S_OK;
2504         UINT32 i;
2505         for(i = 0; i < This->fmt->nChannels; ++i){
2506             HRESULT hr;
2507             hr = ca_setvol(This, i);
2508             if(FAILED(hr))
2509                 ret = hr;
2510         }
2511         return ret;
2512     }
2513
2514     if(This->session->mute)
2515         level = 0;
2516     else
2517         level = This->session->master_vol *
2518             This->session->channel_vols[index] * This->vols[index];
2519
2520     sc = AudioQueueSetParameter(This->aqueue, kAudioQueueParam_Volume, level);
2521     if(sc != noErr)
2522         WARN("Setting _Volume property failed: %lx\n", sc);
2523
2524     return S_OK;
2525 }
2526
2527 static HRESULT ca_session_setvol(AudioSession *session, UINT32 index)
2528 {
2529     HRESULT ret = S_OK;
2530     ACImpl *client;
2531
2532     LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry){
2533         HRESULT hr;
2534         hr = ca_setvol(client, index);
2535         if(FAILED(hr))
2536             ret = hr;
2537     }
2538
2539     return ret;
2540 }
2541
2542 static HRESULT WINAPI SimpleAudioVolume_QueryInterface(
2543         ISimpleAudioVolume *iface, REFIID riid, void **ppv)
2544 {
2545     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2546
2547     if(!ppv)
2548         return E_POINTER;
2549     *ppv = NULL;
2550
2551     if(IsEqualIID(riid, &IID_IUnknown) ||
2552             IsEqualIID(riid, &IID_ISimpleAudioVolume))
2553         *ppv = iface;
2554     if(*ppv){
2555         IUnknown_AddRef((IUnknown*)*ppv);
2556         return S_OK;
2557     }
2558
2559     WARN("Unknown interface %s\n", debugstr_guid(riid));
2560     return E_NOINTERFACE;
2561 }
2562
2563 static ULONG WINAPI SimpleAudioVolume_AddRef(ISimpleAudioVolume *iface)
2564 {
2565     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2566     return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
2567 }
2568
2569 static ULONG WINAPI SimpleAudioVolume_Release(ISimpleAudioVolume *iface)
2570 {
2571     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2572     return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
2573 }
2574
2575 static HRESULT WINAPI SimpleAudioVolume_SetMasterVolume(
2576         ISimpleAudioVolume *iface, float level, const GUID *context)
2577 {
2578     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2579     AudioSession *session = This->session;
2580     HRESULT ret;
2581
2582     TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
2583
2584     if(level < 0.f || level > 1.f)
2585         return E_INVALIDARG;
2586
2587     if(context)
2588         FIXME("Notifications not supported yet\n");
2589
2590     EnterCriticalSection(&session->lock);
2591
2592     session->master_vol = level;
2593
2594     ret = ca_session_setvol(session, -1);
2595
2596     LeaveCriticalSection(&session->lock);
2597
2598     return ret;
2599 }
2600
2601 static HRESULT WINAPI SimpleAudioVolume_GetMasterVolume(
2602         ISimpleAudioVolume *iface, float *level)
2603 {
2604     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2605     AudioSession *session = This->session;
2606
2607     TRACE("(%p)->(%p)\n", session, level);
2608
2609     if(!level)
2610         return NULL_PTR_ERR;
2611
2612     *level = session->master_vol;
2613
2614     return S_OK;
2615 }
2616
2617 static HRESULT WINAPI SimpleAudioVolume_SetMute(ISimpleAudioVolume *iface,
2618         BOOL mute, const GUID *context)
2619 {
2620     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2621     AudioSession *session = This->session;
2622
2623     TRACE("(%p)->(%u, %p)\n", session, mute, context);
2624
2625     if(context)
2626         FIXME("Notifications not supported yet\n");
2627
2628     EnterCriticalSection(&session->lock);
2629
2630     session->mute = mute;
2631
2632     ca_session_setvol(session, -1);
2633
2634     LeaveCriticalSection(&session->lock);
2635
2636     return S_OK;
2637 }
2638
2639 static HRESULT WINAPI SimpleAudioVolume_GetMute(ISimpleAudioVolume *iface,
2640         BOOL *mute)
2641 {
2642     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2643     AudioSession *session = This->session;
2644
2645     TRACE("(%p)->(%p)\n", session, mute);
2646
2647     if(!mute)
2648         return NULL_PTR_ERR;
2649
2650     *mute = session->mute;
2651
2652     return S_OK;
2653 }
2654
2655 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl  =
2656 {
2657     SimpleAudioVolume_QueryInterface,
2658     SimpleAudioVolume_AddRef,
2659     SimpleAudioVolume_Release,
2660     SimpleAudioVolume_SetMasterVolume,
2661     SimpleAudioVolume_GetMasterVolume,
2662     SimpleAudioVolume_SetMute,
2663     SimpleAudioVolume_GetMute
2664 };
2665
2666 static HRESULT WINAPI AudioStreamVolume_QueryInterface(
2667         IAudioStreamVolume *iface, REFIID riid, void **ppv)
2668 {
2669     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2670
2671     if(!ppv)
2672         return E_POINTER;
2673     *ppv = NULL;
2674
2675     if(IsEqualIID(riid, &IID_IUnknown) ||
2676             IsEqualIID(riid, &IID_IAudioStreamVolume))
2677         *ppv = iface;
2678     if(*ppv){
2679         IUnknown_AddRef((IUnknown*)*ppv);
2680         return S_OK;
2681     }
2682
2683     WARN("Unknown interface %s\n", debugstr_guid(riid));
2684     return E_NOINTERFACE;
2685 }
2686
2687 static ULONG WINAPI AudioStreamVolume_AddRef(IAudioStreamVolume *iface)
2688 {
2689     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2690     return IAudioClient_AddRef(&This->IAudioClient_iface);
2691 }
2692
2693 static ULONG WINAPI AudioStreamVolume_Release(IAudioStreamVolume *iface)
2694 {
2695     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2696     return IAudioClient_Release(&This->IAudioClient_iface);
2697 }
2698
2699 static HRESULT WINAPI AudioStreamVolume_GetChannelCount(
2700         IAudioStreamVolume *iface, UINT32 *out)
2701 {
2702     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2703
2704     TRACE("(%p)->(%p)\n", This, out);
2705
2706     if(!out)
2707         return E_POINTER;
2708
2709     *out = This->fmt->nChannels;
2710
2711     return S_OK;
2712 }
2713
2714 static HRESULT WINAPI AudioStreamVolume_SetChannelVolume(
2715         IAudioStreamVolume *iface, UINT32 index, float level)
2716 {
2717     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2718     HRESULT ret;
2719
2720     TRACE("(%p)->(%d, %f)\n", This, index, level);
2721
2722     if(level < 0.f || level > 1.f)
2723         return E_INVALIDARG;
2724
2725     if(index >= This->fmt->nChannels)
2726         return E_INVALIDARG;
2727
2728     OSSpinLockLock(&This->lock);
2729
2730     This->vols[index] = level;
2731
2732     WARN("AudioQueue doesn't support per-channel volume control\n");
2733     ret = ca_setvol(This, index);
2734
2735     OSSpinLockUnlock(&This->lock);
2736
2737     return ret;
2738 }
2739
2740 static HRESULT WINAPI AudioStreamVolume_GetChannelVolume(
2741         IAudioStreamVolume *iface, UINT32 index, float *level)
2742 {
2743     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2744
2745     TRACE("(%p)->(%d, %p)\n", This, index, level);
2746
2747     if(!level)
2748         return E_POINTER;
2749
2750     if(index >= This->fmt->nChannels)
2751         return E_INVALIDARG;
2752
2753     *level = This->vols[index];
2754
2755     return S_OK;
2756 }
2757
2758 static HRESULT WINAPI AudioStreamVolume_SetAllVolumes(
2759         IAudioStreamVolume *iface, UINT32 count, const float *levels)
2760 {
2761     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2762     int i;
2763     HRESULT ret;
2764
2765     TRACE("(%p)->(%d, %p)\n", This, count, levels);
2766
2767     if(!levels)
2768         return E_POINTER;
2769
2770     if(count != This->fmt->nChannels)
2771         return E_INVALIDARG;
2772
2773     OSSpinLockLock(&This->lock);
2774
2775     for(i = 0; i < count; ++i)
2776         This->vols[i] = levels[i];
2777
2778     ret = ca_setvol(This, -1);
2779
2780     OSSpinLockUnlock(&This->lock);
2781
2782     return ret;
2783 }
2784
2785 static HRESULT WINAPI AudioStreamVolume_GetAllVolumes(
2786         IAudioStreamVolume *iface, UINT32 count, float *levels)
2787 {
2788     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2789     int i;
2790
2791     TRACE("(%p)->(%d, %p)\n", This, count, levels);
2792
2793     if(!levels)
2794         return E_POINTER;
2795
2796     if(count != This->fmt->nChannels)
2797         return E_INVALIDARG;
2798
2799     OSSpinLockLock(&This->lock);
2800
2801     for(i = 0; i < count; ++i)
2802         levels[i] = This->vols[i];
2803
2804     OSSpinLockUnlock(&This->lock);
2805
2806     return S_OK;
2807 }
2808
2809 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
2810 {
2811     AudioStreamVolume_QueryInterface,
2812     AudioStreamVolume_AddRef,
2813     AudioStreamVolume_Release,
2814     AudioStreamVolume_GetChannelCount,
2815     AudioStreamVolume_SetChannelVolume,
2816     AudioStreamVolume_GetChannelVolume,
2817     AudioStreamVolume_SetAllVolumes,
2818     AudioStreamVolume_GetAllVolumes
2819 };
2820
2821 static HRESULT WINAPI ChannelAudioVolume_QueryInterface(
2822         IChannelAudioVolume *iface, REFIID riid, void **ppv)
2823 {
2824     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2825
2826     if(!ppv)
2827         return E_POINTER;
2828     *ppv = NULL;
2829
2830     if(IsEqualIID(riid, &IID_IUnknown) ||
2831             IsEqualIID(riid, &IID_IChannelAudioVolume))
2832         *ppv = iface;
2833     if(*ppv){
2834         IUnknown_AddRef((IUnknown*)*ppv);
2835         return S_OK;
2836     }
2837
2838     WARN("Unknown interface %s\n", debugstr_guid(riid));
2839     return E_NOINTERFACE;
2840 }
2841
2842 static ULONG WINAPI ChannelAudioVolume_AddRef(IChannelAudioVolume *iface)
2843 {
2844     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2845     return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
2846 }
2847
2848 static ULONG WINAPI ChannelAudioVolume_Release(IChannelAudioVolume *iface)
2849 {
2850     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2851     return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
2852 }
2853
2854 static HRESULT WINAPI ChannelAudioVolume_GetChannelCount(
2855         IChannelAudioVolume *iface, UINT32 *out)
2856 {
2857     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2858     AudioSession *session = This->session;
2859
2860     TRACE("(%p)->(%p)\n", session, out);
2861
2862     if(!out)
2863         return NULL_PTR_ERR;
2864
2865     *out = session->channel_count;
2866
2867     return S_OK;
2868 }
2869
2870 static HRESULT WINAPI ChannelAudioVolume_SetChannelVolume(
2871         IChannelAudioVolume *iface, UINT32 index, float level,
2872         const GUID *context)
2873 {
2874     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2875     AudioSession *session = This->session;
2876     HRESULT ret;
2877
2878     TRACE("(%p)->(%d, %f, %s)\n", session, index, level,
2879             wine_dbgstr_guid(context));
2880
2881     if(level < 0.f || level > 1.f)
2882         return E_INVALIDARG;
2883
2884     if(index >= session->channel_count)
2885         return E_INVALIDARG;
2886
2887     if(context)
2888         FIXME("Notifications not supported yet\n");
2889
2890     EnterCriticalSection(&session->lock);
2891
2892     session->channel_vols[index] = level;
2893
2894     WARN("AudioQueue doesn't support per-channel volume control\n");
2895     ret = ca_session_setvol(session, index);
2896
2897     LeaveCriticalSection(&session->lock);
2898
2899     return ret;
2900 }
2901
2902 static HRESULT WINAPI ChannelAudioVolume_GetChannelVolume(
2903         IChannelAudioVolume *iface, UINT32 index, float *level)
2904 {
2905     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2906     AudioSession *session = This->session;
2907
2908     TRACE("(%p)->(%d, %p)\n", session, index, level);
2909
2910     if(!level)
2911         return NULL_PTR_ERR;
2912
2913     if(index >= session->channel_count)
2914         return E_INVALIDARG;
2915
2916     *level = session->channel_vols[index];
2917
2918     return S_OK;
2919 }
2920
2921 static HRESULT WINAPI ChannelAudioVolume_SetAllVolumes(
2922         IChannelAudioVolume *iface, UINT32 count, const float *levels,
2923         const GUID *context)
2924 {
2925     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2926     AudioSession *session = This->session;
2927     int i;
2928     HRESULT ret;
2929
2930     TRACE("(%p)->(%d, %p, %s)\n", session, count, levels,
2931             wine_dbgstr_guid(context));
2932
2933     if(!levels)
2934         return NULL_PTR_ERR;
2935
2936     if(count != session->channel_count)
2937         return E_INVALIDARG;
2938
2939     if(context)
2940         FIXME("Notifications not supported yet\n");
2941
2942     EnterCriticalSection(&session->lock);
2943
2944     for(i = 0; i < count; ++i)
2945         session->channel_vols[i] = levels[i];
2946
2947     ret = ca_session_setvol(session, -1);
2948
2949     LeaveCriticalSection(&session->lock);
2950
2951     return ret;
2952 }
2953
2954 static HRESULT WINAPI ChannelAudioVolume_GetAllVolumes(
2955         IChannelAudioVolume *iface, UINT32 count, float *levels)
2956 {
2957     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2958     AudioSession *session = This->session;
2959     int i;
2960
2961     TRACE("(%p)->(%d, %p)\n", session, count, levels);
2962
2963     if(!levels)
2964         return NULL_PTR_ERR;
2965
2966     if(count != session->channel_count)
2967         return E_INVALIDARG;
2968
2969     for(i = 0; i < count; ++i)
2970         levels[i] = session->channel_vols[i];
2971
2972     return S_OK;
2973 }
2974
2975 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
2976 {
2977     ChannelAudioVolume_QueryInterface,
2978     ChannelAudioVolume_AddRef,
2979     ChannelAudioVolume_Release,
2980     ChannelAudioVolume_GetChannelCount,
2981     ChannelAudioVolume_SetChannelVolume,
2982     ChannelAudioVolume_GetChannelVolume,
2983     ChannelAudioVolume_SetAllVolumes,
2984     ChannelAudioVolume_GetAllVolumes
2985 };
2986
2987 static HRESULT WINAPI AudioSessionManager_QueryInterface(IAudioSessionManager2 *iface,
2988         REFIID riid, void **ppv)
2989 {
2990     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2991
2992     if(!ppv)
2993         return E_POINTER;
2994     *ppv = NULL;
2995
2996     if(IsEqualIID(riid, &IID_IUnknown) ||
2997             IsEqualIID(riid, &IID_IAudioSessionManager) ||
2998             IsEqualIID(riid, &IID_IAudioSessionManager2))
2999         *ppv = iface;
3000     if(*ppv){
3001         IUnknown_AddRef((IUnknown*)*ppv);
3002         return S_OK;
3003     }
3004
3005     WARN("Unknown interface %s\n", debugstr_guid(riid));
3006     return E_NOINTERFACE;
3007 }
3008
3009 static ULONG WINAPI AudioSessionManager_AddRef(IAudioSessionManager2 *iface)
3010 {
3011     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3012     ULONG ref;
3013     ref = InterlockedIncrement(&This->ref);
3014     TRACE("(%p) Refcount now %u\n", This, ref);
3015     return ref;
3016 }
3017
3018 static ULONG WINAPI AudioSessionManager_Release(IAudioSessionManager2 *iface)
3019 {
3020     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3021     ULONG ref;
3022     ref = InterlockedDecrement(&This->ref);
3023     TRACE("(%p) Refcount now %u\n", This, ref);
3024     if(!ref)
3025         HeapFree(GetProcessHeap(), 0, This);
3026     return ref;
3027 }
3028
3029 static HRESULT WINAPI AudioSessionManager_GetAudioSessionControl(
3030         IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
3031         IAudioSessionControl **out)
3032 {
3033     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3034     AudioSession *session;
3035     AudioSessionWrapper *wrapper;
3036     HRESULT hr;
3037
3038     TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
3039             flags, out);
3040
3041     hr = get_audio_session(session_guid, This->device, 0, &session);
3042     if(FAILED(hr))
3043         return hr;
3044
3045     wrapper = AudioSessionWrapper_Create(NULL);
3046     if(!wrapper)
3047         return E_OUTOFMEMORY;
3048
3049     wrapper->session = session;
3050
3051     *out = (IAudioSessionControl*)&wrapper->IAudioSessionControl2_iface;
3052
3053     return S_OK;
3054 }
3055
3056 static HRESULT WINAPI AudioSessionManager_GetSimpleAudioVolume(
3057         IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
3058         ISimpleAudioVolume **out)
3059 {
3060     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3061     AudioSession *session;
3062     AudioSessionWrapper *wrapper;
3063     HRESULT hr;
3064
3065     TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
3066             flags, out);
3067
3068     hr = get_audio_session(session_guid, This->device, 0, &session);
3069     if(FAILED(hr))
3070         return hr;
3071
3072     wrapper = AudioSessionWrapper_Create(NULL);
3073     if(!wrapper)
3074         return E_OUTOFMEMORY;
3075
3076     wrapper->session = session;
3077
3078     *out = &wrapper->ISimpleAudioVolume_iface;
3079
3080     return S_OK;
3081 }
3082
3083 static HRESULT WINAPI AudioSessionManager_GetSessionEnumerator(
3084         IAudioSessionManager2 *iface, IAudioSessionEnumerator **out)
3085 {
3086     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3087     FIXME("(%p)->(%p) - stub\n", This, out);
3088     return E_NOTIMPL;
3089 }
3090
3091 static HRESULT WINAPI AudioSessionManager_RegisterSessionNotification(
3092         IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3093 {
3094     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3095     FIXME("(%p)->(%p) - stub\n", This, notification);
3096     return E_NOTIMPL;
3097 }
3098
3099 static HRESULT WINAPI AudioSessionManager_UnregisterSessionNotification(
3100         IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3101 {
3102     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3103     FIXME("(%p)->(%p) - stub\n", This, notification);
3104     return E_NOTIMPL;
3105 }
3106
3107 static HRESULT WINAPI AudioSessionManager_RegisterDuckNotification(
3108         IAudioSessionManager2 *iface, const WCHAR *session_id,
3109         IAudioVolumeDuckNotification *notification)
3110 {
3111     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3112     FIXME("(%p)->(%p) - stub\n", This, notification);
3113     return E_NOTIMPL;
3114 }
3115
3116 static HRESULT WINAPI AudioSessionManager_UnregisterDuckNotification(
3117         IAudioSessionManager2 *iface,
3118         IAudioVolumeDuckNotification *notification)
3119 {
3120     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3121     FIXME("(%p)->(%p) - stub\n", This, notification);
3122     return E_NOTIMPL;
3123 }
3124
3125 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl =
3126 {
3127     AudioSessionManager_QueryInterface,
3128     AudioSessionManager_AddRef,
3129     AudioSessionManager_Release,
3130     AudioSessionManager_GetAudioSessionControl,
3131     AudioSessionManager_GetSimpleAudioVolume,
3132     AudioSessionManager_GetSessionEnumerator,
3133     AudioSessionManager_RegisterSessionNotification,
3134     AudioSessionManager_UnregisterSessionNotification,
3135     AudioSessionManager_RegisterDuckNotification,
3136     AudioSessionManager_UnregisterDuckNotification
3137 };
3138
3139 HRESULT WINAPI AUDDRV_GetAudioSessionManager(IMMDevice *device,
3140         IAudioSessionManager2 **out)
3141 {
3142     SessionMgr *This;
3143
3144     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SessionMgr));
3145     if(!This)
3146         return E_OUTOFMEMORY;
3147
3148     This->IAudioSessionManager2_iface.lpVtbl = &AudioSessionManager2_Vtbl;
3149     This->device = device;
3150     This->ref = 1;
3151
3152     *out = &This->IAudioSessionManager2_iface;
3153
3154     return S_OK;
3155 }