dlls/winecoreaudio.drv/mmdevdrv.c

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