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