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