dlls/wineoss.drv/mmdevdrv.c

   1 /*
   2  * Copyright 2011 Andrew Eikum for CodeWeavers
   3  *           2022 Huw Davies
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winternl.h"
  26 #include "winnls.h"
  27 #include "winreg.h"
  28
  29 #include "ole2.h"
  30 #include "mmdeviceapi.h"
  31 #include "devpkey.h"
  32 #include "dshow.h"
  33 #include "dsound.h"
  34
  35 #include "initguid.h"
  36 #include "endpointvolume.h"
  37 #include "audiopolicy.h"
  38 #include "audioclient.h"
  39
  40 #include "wine/debug.h"
  41 #include "wine/list.h"
  42 #include "wine/unixlib.h"
  43
  44 #include "unixlib.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(oss);
  47
  48 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
  49
  50 unixlib_handle_t oss_handle = 0;
  51
  52 static const REFERENCE_TIME DefaultPeriod = 100000;
  53 static const REFERENCE_TIME MinimumPeriod = 50000;
  54
  55 struct ACImpl;
  56 typedef struct ACImpl ACImpl;
  57
  58 typedef struct _AudioSession {
  59     GUID guid;
  60     struct list clients;
  61
  62     IMMDevice *device;
  63
  64     float master_vol;
  65     UINT32 channel_count;
  66     float *channel_vols;
  67     BOOL mute;
  68
  69     struct list entry;
  70 } AudioSession;
  71
  72 typedef struct _AudioSessionWrapper {
  73     IAudioSessionControl2 IAudioSessionControl2_iface;
  74     IChannelAudioVolume IChannelAudioVolume_iface;
  75     ISimpleAudioVolume ISimpleAudioVolume_iface;
  76
  77     LONG ref;
  78
  79     ACImpl *client;
  80     AudioSession *session;
  81 } AudioSessionWrapper;
  82
  83 struct ACImpl {
  84     IAudioClient3 IAudioClient3_iface;
  85     IAudioRenderClient IAudioRenderClient_iface;
  86     IAudioCaptureClient IAudioCaptureClient_iface;
  87     IAudioClock IAudioClock_iface;
  88     IAudioClock2 IAudioClock2_iface;
  89     IAudioStreamVolume IAudioStreamVolume_iface;
  90
  91     LONG ref;
  92
  93     IMMDevice *parent;
  94     IUnknown *pUnkFTMarshal;
  95
  96     EDataFlow dataflow;
  97     float *vols;
  98     UINT32 channel_count;
  99     stream_handle stream;
 100
 101     HANDLE timer_thread;
 102
 103     AudioSession *session;
 104     AudioSessionWrapper *session_wrapper;
 105
 106     struct list entry;
 107
 108     /* Keep at end */
 109     char devnode[0];
 110 };
 111
 112 typedef struct _SessionMgr {
 113     IAudioSessionManager2 IAudioSessionManager2_iface;
 114
 115     LONG ref;
 116
 117     IMMDevice *device;
 118 } SessionMgr;
 119
 120 typedef struct _OSSDevice {
 121     struct list entry;
 122     EDataFlow flow;
 123     GUID guid;
 124     char devnode[0];
 125 } OSSDevice;
 126
 127 static struct list g_devices = LIST_INIT(g_devices);
 128
 129 static const WCHAR drv_key_devicesW[] = {'S','o','f','t','w','a','r','e','\\',
 130     'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
 131     'w','i','n','e','o','s','s','.','d','r','v','\\','d','e','v','i','c','e','s',0};
 132 static const WCHAR guidW[] = {'g','u','i','d',0};
 133
 134 static CRITICAL_SECTION g_sessions_lock;
 135 static CRITICAL_SECTION_DEBUG g_sessions_lock_debug =
 136 {
 137     0, 0, &g_sessions_lock,
 138     { &g_sessions_lock_debug.ProcessLocksList, &g_sessions_lock_debug.ProcessLocksList },
 139       0, 0, { (DWORD_PTR)(__FILE__ ": g_sessions_lock") }
 140 };
 141 static CRITICAL_SECTION g_sessions_lock = { &g_sessions_lock_debug, -1, 0, 0, 0, 0 };
 142 static struct list g_sessions = LIST_INIT(g_sessions);
 143
 144 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client);
 145
 146 static const IAudioClient3Vtbl AudioClient3_Vtbl;
 147 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl;
 148 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl;
 149 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl;
 150 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl;
 151 static const IAudioClockVtbl AudioClock_Vtbl;
 152 static const IAudioClock2Vtbl AudioClock2_Vtbl;
 153 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl;
 154 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl;
 155 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl;
 156
 157 static inline ACImpl *impl_from_IAudioClient3(IAudioClient3 *iface)
 158 {
 159     return CONTAINING_RECORD(iface, ACImpl, IAudioClient3_iface);
 160 }
 161
 162 static inline ACImpl *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
 163 {
 164     return CONTAINING_RECORD(iface, ACImpl, IAudioRenderClient_iface);
 165 }
 166
 167 static inline ACImpl *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
 168 {
 169     return CONTAINING_RECORD(iface, ACImpl, IAudioCaptureClient_iface);
 170 }
 171
 172 static inline AudioSessionWrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
 173 {
 174     return CONTAINING_RECORD(iface, AudioSessionWrapper, IAudioSessionControl2_iface);
 175 }
 176
 177 static inline AudioSessionWrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
 178 {
 179     return CONTAINING_RECORD(iface, AudioSessionWrapper, ISimpleAudioVolume_iface);
 180 }
 181
 182 static inline AudioSessionWrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
 183 {
 184     return CONTAINING_RECORD(iface, AudioSessionWrapper, IChannelAudioVolume_iface);
 185 }
 186
 187 static inline ACImpl *impl_from_IAudioClock(IAudioClock *iface)
 188 {
 189     return CONTAINING_RECORD(iface, ACImpl, IAudioClock_iface);
 190 }
 191
 192 static inline ACImpl *impl_from_IAudioClock2(IAudioClock2 *iface)
 193 {
 194     return CONTAINING_RECORD(iface, ACImpl, IAudioClock2_iface);
 195 }
 196
 197 static inline ACImpl *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
 198 {
 199     return CONTAINING_RECORD(iface, ACImpl, IAudioStreamVolume_iface);
 200 }
 201
 202 static inline SessionMgr *impl_from_IAudioSessionManager2(IAudioSessionManager2 *iface)
 203 {
 204     return CONTAINING_RECORD(iface, SessionMgr, IAudioSessionManager2_iface);
 205 }
 206
 207 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved)
 208 {
 209     switch (reason)
 210     {
 211     case DLL_PROCESS_ATTACH:
 212         if(NtQueryVirtualMemory(GetCurrentProcess(), dll, MemoryWineUnixFuncs,
 213                                 &oss_handle, sizeof(oss_handle), NULL))
 214             return FALSE;
 215         break;
 216
 217     case DLL_PROCESS_DETACH:
 218         if (!reserved)
 219         {
 220             OSSDevice *iter, *iter2;
 221
 222             DeleteCriticalSection(&g_sessions_lock);
 223
 224             LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &g_devices, OSSDevice, entry){
 225                 HeapFree(GetProcessHeap(), 0, iter);
 226             }
 227         }
 228         break;
 229     }
 230     return TRUE;
 231 }
 232
 233 int WINAPI AUDDRV_GetPriority(void)
 234 {
 235     struct test_connect_params params;
 236
 237     OSS_CALL(test_connect, &params);
 238
 239     return params.priority;
 240 }
 241
 242 static HRESULT stream_release(stream_handle stream, HANDLE timer_thread)
 243 {
 244     struct release_stream_params params;
 245
 246     params.stream = stream;
 247     params.timer_thread = timer_thread;
 248     OSS_CALL(release_stream, &params);
 249
 250     return params.result;
 251 }
 252
 253 static DWORD WINAPI timer_thread(void *user)
 254 {
 255     struct timer_loop_params params;
 256     struct ACImpl *This = user;
 257
 258     params.stream = This->stream;
 259     OSS_CALL(timer_loop, &params);
 260
 261     return 0;
 262 }
 263
 264 static void set_device_guid(EDataFlow flow, HKEY drv_key, const WCHAR *key_name,
 265         GUID *guid)
 266 {
 267     HKEY key;
 268     BOOL opened = FALSE;
 269     LONG lr;
 270
 271     if(!drv_key){
 272         lr = RegCreateKeyExW(HKEY_CURRENT_USER, drv_key_devicesW, 0, NULL, 0, KEY_WRITE,
 273                     NULL, &drv_key, NULL);
 274         if(lr != ERROR_SUCCESS){
 275             ERR("RegCreateKeyEx(drv_key) failed: %lu\n", lr);
 276             return;
 277         }
 278         opened = TRUE;
 279     }
 280
 281     lr = RegCreateKeyExW(drv_key, key_name, 0, NULL, 0, KEY_WRITE,
 282                 NULL, &key, NULL);
 283     if(lr != ERROR_SUCCESS){
 284         ERR("RegCreateKeyEx(%s) failed: %lu\n", wine_dbgstr_w(key_name), lr);
 285         goto exit;
 286     }
 287
 288     lr = RegSetValueExW(key, guidW, 0, REG_BINARY, (BYTE*)guid,
 289                 sizeof(GUID));
 290     if(lr != ERROR_SUCCESS)
 291         ERR("RegSetValueEx(%s\\guid) failed: %lu\n", wine_dbgstr_w(key_name), lr);
 292
 293     RegCloseKey(key);
 294 exit:
 295     if(opened)
 296         RegCloseKey(drv_key);
 297 }
 298
 299 static void get_device_guid(EDataFlow flow, const char *device, GUID *guid)
 300 {
 301     HKEY key = NULL, dev_key;
 302     DWORD type, size = sizeof(*guid);
 303     WCHAR key_name[256];
 304
 305     if(flow == eCapture)
 306         key_name[0] = '1';
 307     else
 308         key_name[0] = '0';
 309     key_name[1] = ',';
 310     MultiByteToWideChar(CP_UNIXCP, 0, device, -1, key_name + 2, ARRAY_SIZE(key_name) - 2);
 311
 312     if(RegOpenKeyExW(HKEY_CURRENT_USER, drv_key_devicesW, 0, KEY_WRITE|KEY_READ, &key) == ERROR_SUCCESS){
 313         if(RegOpenKeyExW(key, key_name, 0, KEY_READ, &dev_key) == ERROR_SUCCESS){
 314             if(RegQueryValueExW(dev_key, guidW, 0, &type,
 315                         (BYTE*)guid, &size) == ERROR_SUCCESS){
 316                 if(type == REG_BINARY){
 317                     RegCloseKey(dev_key);
 318                     RegCloseKey(key);
 319                     return;
 320                 }
 321                 ERR("Invalid type for device %s GUID: %lu; ignoring and overwriting\n",
 322                         wine_dbgstr_w(key_name), type);
 323             }
 324             RegCloseKey(dev_key);
 325         }
 326     }
 327
 328     CoCreateGuid(guid);
 329
 330     set_device_guid(flow, key, key_name, guid);
 331
 332     if(key)
 333         RegCloseKey(key);
 334 }
 335
 336 static void set_stream_volumes(ACImpl *This)
 337 {
 338     struct set_volumes_params params;
 339
 340     params.stream = This->stream;
 341     params.master_volume = (This->session->mute ? 0.0f : This->session->master_vol);
 342     params.volumes = This->vols;
 343     params.session_volumes = This->session->channel_vols;
 344     OSS_CALL(set_volumes, &params);
 345 }
 346
 347 static const OSSDevice *get_ossdevice_from_guid(const GUID *guid)
 348 {
 349     OSSDevice *dev_item;
 350     LIST_FOR_EACH_ENTRY(dev_item, &g_devices, OSSDevice, entry)
 351         if(IsEqualGUID(guid, &dev_item->guid))
 352             return dev_item;
 353     return NULL;
 354 }
 355
 356 static void device_add(OSSDevice *oss_dev)
 357 {
 358     if(get_ossdevice_from_guid(&oss_dev->guid)) /* already in list */
 359         HeapFree(GetProcessHeap(), 0, oss_dev);
 360     else
 361         list_add_tail(&g_devices, &oss_dev->entry);
 362 }
 363
 364 HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, GUID **guids_out,
 365         UINT *num, UINT *def_index)
 366 {
 367     struct get_endpoint_ids_params params;
 368     GUID *guids = NULL;
 369     WCHAR **ids = NULL;
 370     unsigned int i;
 371
 372     TRACE("%d %p %p %p %p\n", flow, ids, guids, num, def_index);
 373
 374     params.flow = flow;
 375     params.size = 1000;
 376     params.endpoints = NULL;
 377     do{
 378         HeapFree(GetProcessHeap(), 0, params.endpoints);
 379         params.endpoints = HeapAlloc(GetProcessHeap(), 0, params.size);
 380         OSS_CALL(get_endpoint_ids, &params);
 381     }while(params.result == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER));
 382
 383     if(FAILED(params.result)) goto end;
 384
 385     ids = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, params.num * sizeof(*ids));
 386     guids = HeapAlloc(GetProcessHeap(), 0, params.num * sizeof(*guids));
 387     if(!ids || !guids){
 388         params.result = E_OUTOFMEMORY;
 389         goto end;
 390     }
 391
 392     for(i = 0; i < params.num; i++){
 393         WCHAR *name = (WCHAR *)((char *)params.endpoints + params.endpoints[i].name);
 394         char *device = (char *)params.endpoints + params.endpoints[i].device;
 395         unsigned int name_size = (wcslen(name) + 1) * sizeof(WCHAR);
 396         unsigned int dev_size = strlen(device) + 1;
 397         OSSDevice *oss_dev;
 398
 399         ids[i] = HeapAlloc(GetProcessHeap(), 0, name_size);
 400         oss_dev = HeapAlloc(GetProcessHeap(), 0, offsetof(OSSDevice, devnode[dev_size]));
 401         if(!ids[i] || !oss_dev){
 402             HeapFree(GetProcessHeap(), 0, oss_dev);
 403             params.result = E_OUTOFMEMORY;
 404             goto end;
 405         }
 406         memcpy(ids[i], name, name_size);
 407         get_device_guid(flow, device, guids + i);
 408
 409         oss_dev->flow = flow;
 410         oss_dev->guid = guids[i];
 411         memcpy(oss_dev->devnode, device, dev_size);
 412         device_add(oss_dev);
 413     }
 414     *def_index = params.default_idx;
 415
 416 end:
 417     HeapFree(GetProcessHeap(), 0, params.endpoints);
 418     if(FAILED(params.result)){
 419         HeapFree(GetProcessHeap(), 0, guids);
 420         if(ids){
 421             for(i = 0; i < params.num; i++)
 422                 HeapFree(GetProcessHeap(), 0, ids[i]);
 423             HeapFree(GetProcessHeap(), 0, ids);
 424         }
 425     }else{
 426         *ids_out = ids;
 427         *guids_out = guids;
 428         *num = params.num;
 429     }
 430
 431     return params.result;
 432 }
 433
 434 HRESULT WINAPI AUDDRV_GetAudioEndpoint(GUID *guid, IMMDevice *dev,
 435         IAudioClient **out)
 436 {
 437     ACImpl *This;
 438     const OSSDevice *oss_dev;
 439     HRESULT hr;
 440     int len;
 441
 442     TRACE("%s %p %p\n", debugstr_guid(guid), dev, out);
 443
 444     oss_dev = get_ossdevice_from_guid(guid);
 445     if(!oss_dev){
 446         WARN("Unknown GUID: %s\n", debugstr_guid(guid));
 447         return AUDCLNT_E_DEVICE_INVALIDATED;
 448     }
 449     len = strlen(oss_dev->devnode);
 450     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, offsetof(ACImpl, devnode[len + 1]));
 451     if(!This)
 452         return E_OUTOFMEMORY;
 453
 454     hr = CoCreateFreeThreadedMarshaler((IUnknown *)&This->IAudioClient3_iface, &This->pUnkFTMarshal);
 455     if (FAILED(hr)) {
 456          HeapFree(GetProcessHeap(), 0, This);
 457          return hr;
 458     }
 459
 460     This->dataflow = oss_dev->flow;
 461     strcpy(This->devnode, oss_dev->devnode);
 462
 463     This->IAudioClient3_iface.lpVtbl = &AudioClient3_Vtbl;
 464     This->IAudioRenderClient_iface.lpVtbl = &AudioRenderClient_Vtbl;
 465     This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
 466     This->IAudioClock_iface.lpVtbl = &AudioClock_Vtbl;
 467     This->IAudioClock2_iface.lpVtbl = &AudioClock2_Vtbl;
 468     This->IAudioStreamVolume_iface.lpVtbl = &AudioStreamVolume_Vtbl;
 469
 470     This->parent = dev;
 471     IMMDevice_AddRef(This->parent);
 472
 473     *out = (IAudioClient *)&This->IAudioClient3_iface;
 474     IAudioClient3_AddRef(&This->IAudioClient3_iface);
 475
 476     return S_OK;
 477 }
 478
 479 static HRESULT WINAPI AudioClient_QueryInterface(IAudioClient3 *iface,
 480         REFIID riid, void **ppv)
 481 {
 482     ACImpl *This = impl_from_IAudioClient3(iface);
 483     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 484
 485     if(!ppv)
 486         return E_POINTER;
 487     *ppv = NULL;
 488     if(IsEqualIID(riid, &IID_IUnknown) ||
 489             IsEqualIID(riid, &IID_IAudioClient) ||
 490             IsEqualIID(riid, &IID_IAudioClient2) ||
 491             IsEqualIID(riid, &IID_IAudioClient3))
 492         *ppv = iface;
 493     else if(IsEqualIID(riid, &IID_IMarshal))
 494         return IUnknown_QueryInterface(This->pUnkFTMarshal, riid, ppv);
 495     if(*ppv){
 496         IUnknown_AddRef((IUnknown*)*ppv);
 497         return S_OK;
 498     }
 499     WARN("Unknown interface %s\n", debugstr_guid(riid));
 500     return E_NOINTERFACE;
 501 }
 502
 503 static ULONG WINAPI AudioClient_AddRef(IAudioClient3 *iface)
 504 {
 505     ACImpl *This = impl_from_IAudioClient3(iface);
 506     ULONG ref;
 507     ref = InterlockedIncrement(&This->ref);
 508     TRACE("(%p) Refcount now %lu\n", This, ref);
 509     return ref;
 510 }
 511
 512 static ULONG WINAPI AudioClient_Release(IAudioClient3 *iface)
 513 {
 514     ACImpl *This = impl_from_IAudioClient3(iface);
 515     ULONG ref;
 516
 517     ref = InterlockedDecrement(&This->ref);
 518     TRACE("(%p) Refcount now %lu\n", This, ref);
 519     if(!ref){
 520         IAudioClient3_Stop(iface);
 521         IMMDevice_Release(This->parent);
 522         IUnknown_Release(This->pUnkFTMarshal);
 523         if(This->session){
 524             EnterCriticalSection(&g_sessions_lock);
 525             list_remove(&This->entry);
 526             LeaveCriticalSection(&g_sessions_lock);
 527         }
 528         HeapFree(GetProcessHeap(), 0, This->vols);
 529         if(This->stream)
 530             stream_release(This->stream, This->timer_thread);
 531         HeapFree(GetProcessHeap(), 0, This);
 532     }
 533     return ref;
 534 }
 535
 536 static void dump_fmt(const WAVEFORMATEX *fmt)
 537 {
 538     TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
 539     switch(fmt->wFormatTag){
 540     case WAVE_FORMAT_PCM:
 541         TRACE("WAVE_FORMAT_PCM");
 542         break;
 543     case WAVE_FORMAT_IEEE_FLOAT:
 544         TRACE("WAVE_FORMAT_IEEE_FLOAT");
 545         break;
 546     case WAVE_FORMAT_EXTENSIBLE:
 547         TRACE("WAVE_FORMAT_EXTENSIBLE");
 548         break;
 549     default:
 550         TRACE("Unknown");
 551         break;
 552     }
 553     TRACE(")\n");
 554
 555     TRACE("nChannels: %u\n", fmt->nChannels);
 556     TRACE("nSamplesPerSec: %lu\n", fmt->nSamplesPerSec);
 557     TRACE("nAvgBytesPerSec: %lu\n", fmt->nAvgBytesPerSec);
 558     TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
 559     TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
 560     TRACE("cbSize: %u\n", fmt->cbSize);
 561
 562     if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
 563         WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
 564         TRACE("dwChannelMask: %08lx\n", fmtex->dwChannelMask);
 565         TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
 566         TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
 567     }
 568 }
 569
 570 static void session_init_vols(AudioSession *session, UINT channels)
 571 {
 572     if(session->channel_count < channels){
 573         UINT i;
 574
 575         if(session->channel_vols)
 576             session->channel_vols = HeapReAlloc(GetProcessHeap(), 0,
 577                     session->channel_vols, sizeof(float) * channels);
 578         else
 579             session->channel_vols = HeapAlloc(GetProcessHeap(), 0,
 580                     sizeof(float) * channels);
 581         if(!session->channel_vols)
 582             return;
 583
 584         for(i = session->channel_count; i < channels; ++i)
 585             session->channel_vols[i] = 1.f;
 586
 587         session->channel_count = channels;
 588     }
 589 }
 590
 591 static AudioSession *create_session(const GUID *guid, IMMDevice *device,
 592         UINT num_channels)
 593 {
 594     AudioSession *ret;
 595
 596     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioSession));
 597     if(!ret)
 598         return NULL;
 599
 600     memcpy(&ret->guid, guid, sizeof(GUID));
 601
 602     ret->device = device;
 603
 604     list_init(&ret->clients);
 605
 606     list_add_head(&g_sessions, &ret->entry);
 607
 608     session_init_vols(ret, num_channels);
 609
 610     ret->master_vol = 1.f;
 611
 612     return ret;
 613 }
 614
 615 /* if channels == 0, then this will return or create a session with
 616  * matching dataflow and GUID. otherwise, channels must also match */
 617 static HRESULT get_audio_session(const GUID *sessionguid,
 618         IMMDevice *device, UINT channels, AudioSession **out)
 619 {
 620     AudioSession *session;
 621
 622     if(!sessionguid || IsEqualGUID(sessionguid, &GUID_NULL)){
 623         *out = create_session(&GUID_NULL, device, channels);
 624         if(!*out)
 625             return E_OUTOFMEMORY;
 626
 627         return S_OK;
 628     }
 629
 630     *out = NULL;
 631     LIST_FOR_EACH_ENTRY(session, &g_sessions, AudioSession, entry){
 632         if(session->device == device &&
 633                 IsEqualGUID(sessionguid, &session->guid)){
 634             session_init_vols(session, channels);
 635             *out = session;
 636             break;
 637         }
 638     }
 639
 640     if(!*out){
 641         *out = create_session(sessionguid, device, channels);
 642         if(!*out)
 643             return E_OUTOFMEMORY;
 644     }
 645
 646     return S_OK;
 647 }
 648
 649 static HRESULT WINAPI AudioClient_Initialize(IAudioClient3 *iface,
 650         AUDCLNT_SHAREMODE mode, DWORD flags, REFERENCE_TIME duration,
 651         REFERENCE_TIME period, const WAVEFORMATEX *fmt,
 652         const GUID *sessionguid)
 653 {
 654     ACImpl *This = impl_from_IAudioClient3(iface);
 655     struct create_stream_params params;
 656     stream_handle stream;
 657     unsigned int i;
 658
 659     TRACE("(%p)->(%x, %lx, %s, %s, %p, %s)\n", This, mode, flags,
 660           wine_dbgstr_longlong(duration), wine_dbgstr_longlong(period), fmt, debugstr_guid(sessionguid));
 661
 662     if(!fmt)
 663         return E_POINTER;
 664
 665     dump_fmt(fmt);
 666
 667     if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
 668         return E_INVALIDARG;
 669
 670     if(flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
 671                 AUDCLNT_STREAMFLAGS_LOOPBACK |
 672                 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
 673                 AUDCLNT_STREAMFLAGS_NOPERSIST |
 674                 AUDCLNT_STREAMFLAGS_RATEADJUST |
 675                 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
 676                 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
 677                 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED |
 678                 AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY |
 679                 AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM)){
 680         FIXME("Unknown flags: %08lx\n", flags);
 681         return E_INVALIDARG;
 682     }
 683
 684     if(mode == AUDCLNT_SHAREMODE_SHARED){
 685         period = DefaultPeriod;
 686         if( duration < 3 * period)
 687             duration = 3 * period;
 688     }else{
 689         if(!period)
 690             period = DefaultPeriod; /* not minimum */
 691         if(period < MinimumPeriod || period > 5000000)
 692             return AUDCLNT_E_INVALID_DEVICE_PERIOD;
 693         if(duration > 20000000) /* the smaller the period, the lower this limit */
 694             return AUDCLNT_E_BUFFER_SIZE_ERROR;
 695         if(flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK){
 696             if(duration != period)
 697                 return AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL;
 698             FIXME("EXCLUSIVE mode with EVENTCALLBACK\n");
 699             return AUDCLNT_E_DEVICE_IN_USE;
 700         }else{
 701             if( duration < 8 * period)
 702                 duration = 8 * period; /* may grow above 2s */
 703         }
 704     }
 705
 706     EnterCriticalSection(&g_sessions_lock);
 707
 708     if(This->stream){
 709         LeaveCriticalSection(&g_sessions_lock);
 710         return AUDCLNT_E_ALREADY_INITIALIZED;
 711     }
 712
 713     params.device = This->devnode;
 714     params.flow = This->dataflow;
 715     params.share = mode;
 716     params.flags = flags;
 717     params.duration = duration;
 718     params.period = period;
 719     params.fmt = fmt;
 720     params.stream = &stream;
 721
 722     OSS_CALL(create_stream, &params);
 723     if(FAILED(params.result)){
 724         LeaveCriticalSection(&g_sessions_lock);
 725         return params.result;
 726     }
 727
 728     This->channel_count = fmt->nChannels;
 729     This->vols = HeapAlloc(GetProcessHeap(), 0, This->channel_count * sizeof(float));
 730     if(!This->vols){
 731         params.result = E_OUTOFMEMORY;
 732         goto exit;
 733     }
 734     for(i = 0; i < This->channel_count; ++i)
 735         This->vols[i] = 1.f;
 736
 737     params.result = get_audio_session(sessionguid, This->parent, This->channel_count,
 738             &This->session);
 739
 740 exit:
 741     if(FAILED(params.result)){
 742         stream_release(stream, NULL);
 743         HeapFree(GetProcessHeap(), 0, This->vols);
 744         This->vols = NULL;
 745     } else {
 746         list_add_tail(&This->session->clients, &This->entry);
 747         This->stream = stream;
 748         set_stream_volumes(This);
 749     }
 750
 751     LeaveCriticalSection(&g_sessions_lock);
 752
 753     return params.result;
 754 }
 755
 756 static HRESULT WINAPI AudioClient_GetBufferSize(IAudioClient3 *iface,
 757         UINT32 *frames)
 758 {
 759     ACImpl *This = impl_from_IAudioClient3(iface);
 760     struct get_buffer_size_params params;
 761
 762     TRACE("(%p)->(%p)\n", This, frames);
 763
 764     if(!frames)
 765         return E_POINTER;
 766
 767     if(!This->stream)
 768         return AUDCLNT_E_NOT_INITIALIZED;
 769
 770     params.stream = This->stream;
 771     params.size = frames;
 772
 773     OSS_CALL(get_buffer_size, &params);
 774     TRACE("buffer size: %u\n", *frames);
 775
 776     return params.result;
 777 }
 778
 779 static HRESULT WINAPI AudioClient_GetStreamLatency(IAudioClient3 *iface,
 780         REFERENCE_TIME *latency)
 781 {
 782     ACImpl *This = impl_from_IAudioClient3(iface);
 783     struct get_latency_params params;
 784
 785     TRACE("(%p)->(%p)\n", This, latency);
 786
 787     if(!latency)
 788         return E_POINTER;
 789
 790     if(!This->stream)
 791         return AUDCLNT_E_NOT_INITIALIZED;
 792
 793     params.stream = This->stream;
 794     params.latency = latency;
 795     OSS_CALL(get_latency, &params);
 796
 797     return params.result;
 798 }
 799
 800 static HRESULT WINAPI AudioClient_GetCurrentPadding(IAudioClient3 *iface,
 801         UINT32 *numpad)
 802 {
 803     ACImpl *This = impl_from_IAudioClient3(iface);
 804     struct get_current_padding_params params;
 805
 806     TRACE("(%p)->(%p)\n", This, numpad);
 807
 808     if(!numpad)
 809         return E_POINTER;
 810
 811     if(!This->stream)
 812         return AUDCLNT_E_NOT_INITIALIZED;
 813
 814     params.stream = This->stream;
 815     params.padding = numpad;
 816     OSS_CALL(get_current_padding, &params);
 817     TRACE("padding: %u\n", *numpad);
 818
 819     return params.result;
 820 }
 821
 822 static HRESULT WINAPI AudioClient_IsFormatSupported(IAudioClient3 *iface,
 823         AUDCLNT_SHAREMODE mode, const WAVEFORMATEX *fmt,
 824         WAVEFORMATEX **out)
 825 {
 826     ACImpl *This = impl_from_IAudioClient3(iface);
 827     struct is_format_supported_params params;
 828
 829     TRACE("(%p)->(%x, %p, %p)\n", This, mode, fmt, out);
 830     if(fmt) dump_fmt(fmt);
 831
 832     params.device = This->devnode;
 833     params.flow = This->dataflow;
 834     params.share = mode;
 835     params.fmt_in = fmt;
 836     params.fmt_out = NULL;
 837
 838     if(out){
 839         *out = NULL;
 840         if(mode == AUDCLNT_SHAREMODE_SHARED)
 841             params.fmt_out = CoTaskMemAlloc(sizeof(*params.fmt_out));
 842     }
 843     OSS_CALL(is_format_supported, &params);
 844
 845     if(params.result == S_FALSE)
 846         *out = &params.fmt_out->Format;
 847     else
 848         CoTaskMemFree(params.fmt_out);
 849
 850     return params.result;
 851 }
 852
 853 static HRESULT WINAPI AudioClient_GetMixFormat(IAudioClient3 *iface,
 854         WAVEFORMATEX **pwfx)
 855 {
 856     ACImpl *This = impl_from_IAudioClient3(iface);
 857     struct get_mix_format_params params;
 858
 859     TRACE("(%p)->(%p)\n", This, pwfx);
 860
 861     if(!pwfx)
 862         return E_POINTER;
 863     *pwfx = NULL;
 864
 865     params.device = This->devnode;
 866     params.flow = This->dataflow;
 867     params.fmt = CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE));
 868     if(!params.fmt)
 869         return E_OUTOFMEMORY;
 870
 871     OSS_CALL(get_mix_format, &params);
 872
 873     if(SUCCEEDED(params.result)){
 874         *pwfx = &params.fmt->Format;
 875         dump_fmt(*pwfx);
 876     } else
 877         CoTaskMemFree(params.fmt);
 878
 879     return params.result;
 880 }
 881
 882 static HRESULT WINAPI AudioClient_GetDevicePeriod(IAudioClient3 *iface,
 883         REFERENCE_TIME *defperiod, REFERENCE_TIME *minperiod)
 884 {
 885     ACImpl *This = impl_from_IAudioClient3(iface);
 886
 887     TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
 888
 889     if(!defperiod && !minperiod)
 890         return E_POINTER;
 891
 892     if(defperiod)
 893         *defperiod = DefaultPeriod;
 894     if(minperiod)
 895         *minperiod = MinimumPeriod;
 896
 897     return S_OK;
 898 }
 899
 900 static HRESULT WINAPI AudioClient_Start(IAudioClient3 *iface)
 901 {
 902     ACImpl *This = impl_from_IAudioClient3(iface);
 903     struct start_params params;
 904
 905     TRACE("(%p)\n", This);
 906
 907     EnterCriticalSection(&g_sessions_lock);
 908
 909     if(!This->stream){
 910         LeaveCriticalSection(&g_sessions_lock);
 911         return AUDCLNT_E_NOT_INITIALIZED;
 912     }
 913
 914     params.stream = This->stream;
 915     OSS_CALL(start, &params);
 916
 917     if(SUCCEEDED(params.result) && !This->timer_thread){
 918         This->timer_thread = CreateThread(NULL, 0, timer_thread, This, 0, NULL);
 919         SetThreadPriority(This->timer_thread, THREAD_PRIORITY_TIME_CRITICAL);
 920     }
 921
 922     LeaveCriticalSection(&g_sessions_lock);
 923
 924     return params.result;
 925 }
 926
 927 static HRESULT WINAPI AudioClient_Stop(IAudioClient3 *iface)
 928 {
 929     ACImpl *This = impl_from_IAudioClient3(iface);
 930     struct stop_params params;
 931
 932     TRACE("(%p)\n", This);
 933
 934     if(!This->stream)
 935         return AUDCLNT_E_NOT_INITIALIZED;
 936
 937     params.stream = This->stream;
 938     OSS_CALL(stop, &params);
 939
 940     return params.result;
 941 }
 942
 943 static HRESULT WINAPI AudioClient_Reset(IAudioClient3 *iface)
 944 {
 945     ACImpl *This = impl_from_IAudioClient3(iface);
 946     struct reset_params params;
 947
 948     TRACE("(%p)\n", This);
 949
 950     if(!This->stream)
 951         return AUDCLNT_E_NOT_INITIALIZED;
 952
 953     params.stream = This->stream;
 954     OSS_CALL(reset, &params);
 955
 956     return params.result;
 957 }
 958
 959 static HRESULT WINAPI AudioClient_SetEventHandle(IAudioClient3 *iface,
 960         HANDLE event)
 961 {
 962     ACImpl *This = impl_from_IAudioClient3(iface);
 963     struct set_event_handle_params params;
 964
 965     TRACE("(%p)->(%p)\n", This, event);
 966
 967     if(!event)
 968         return E_INVALIDARG;
 969
 970     if(!This->stream)
 971         return AUDCLNT_E_NOT_INITIALIZED;
 972
 973     params.stream = This->stream;
 974     params.event = event;
 975     OSS_CALL(set_event_handle, &params);
 976
 977     return params.result;
 978 }
 979
 980 static HRESULT WINAPI AudioClient_GetService(IAudioClient3 *iface, REFIID riid,
 981         void **ppv)
 982 {
 983     ACImpl *This = impl_from_IAudioClient3(iface);
 984
 985     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 986
 987     if(!ppv)
 988         return E_POINTER;
 989     *ppv = NULL;
 990
 991     EnterCriticalSection(&g_sessions_lock);
 992
 993     if(!This->stream){
 994         LeaveCriticalSection(&g_sessions_lock);
 995         return AUDCLNT_E_NOT_INITIALIZED;
 996     }
 997
 998     if(IsEqualIID(riid, &IID_IAudioRenderClient)){
 999         if(This->dataflow != eRender){
1000             LeaveCriticalSection(&g_sessions_lock);
1001             return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1002         }
1003         IAudioRenderClient_AddRef(&This->IAudioRenderClient_iface);
1004         *ppv = &This->IAudioRenderClient_iface;
1005     }else if(IsEqualIID(riid, &IID_IAudioCaptureClient)){
1006         if(This->dataflow != eCapture){
1007             LeaveCriticalSection(&g_sessions_lock);
1008             return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1009         }
1010         IAudioCaptureClient_AddRef(&This->IAudioCaptureClient_iface);
1011         *ppv = &This->IAudioCaptureClient_iface;
1012     }else if(IsEqualIID(riid, &IID_IAudioClock)){
1013         IAudioClock_AddRef(&This->IAudioClock_iface);
1014         *ppv = &This->IAudioClock_iface;
1015     }else if(IsEqualIID(riid, &IID_IAudioStreamVolume)){
1016         IAudioStreamVolume_AddRef(&This->IAudioStreamVolume_iface);
1017         *ppv = &This->IAudioStreamVolume_iface;
1018     }else if(IsEqualIID(riid, &IID_IAudioSessionControl)){
1019         if(!This->session_wrapper){
1020             This->session_wrapper = AudioSessionWrapper_Create(This);
1021             if(!This->session_wrapper){
1022                 LeaveCriticalSection(&g_sessions_lock);
1023                 return E_OUTOFMEMORY;
1024             }
1025         }else
1026             IAudioSessionControl2_AddRef(&This->session_wrapper->IAudioSessionControl2_iface);
1027
1028         *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
1029     }else if(IsEqualIID(riid, &IID_IChannelAudioVolume)){
1030         if(!This->session_wrapper){
1031             This->session_wrapper = AudioSessionWrapper_Create(This);
1032             if(!This->session_wrapper){
1033                 LeaveCriticalSection(&g_sessions_lock);
1034                 return E_OUTOFMEMORY;
1035             }
1036         }else
1037             IChannelAudioVolume_AddRef(&This->session_wrapper->IChannelAudioVolume_iface);
1038
1039         *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
1040     }else if(IsEqualIID(riid, &IID_ISimpleAudioVolume)){
1041         if(!This->session_wrapper){
1042             This->session_wrapper = AudioSessionWrapper_Create(This);
1043             if(!This->session_wrapper){
1044                 LeaveCriticalSection(&g_sessions_lock);
1045                 return E_OUTOFMEMORY;
1046             }
1047         }else
1048             ISimpleAudioVolume_AddRef(&This->session_wrapper->ISimpleAudioVolume_iface);
1049
1050         *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
1051     }
1052
1053     if(*ppv){
1054         LeaveCriticalSection(&g_sessions_lock);
1055         return S_OK;
1056     }
1057
1058     LeaveCriticalSection(&g_sessions_lock);
1059
1060     FIXME("stub %s\n", debugstr_guid(riid));
1061     return E_NOINTERFACE;
1062 }
1063
1064 static HRESULT WINAPI AudioClient_IsOffloadCapable(IAudioClient3 *iface,
1065         AUDIO_STREAM_CATEGORY category, BOOL *offload_capable)
1066 {
1067     ACImpl *This = impl_from_IAudioClient3(iface);
1068
1069     TRACE("(%p)->(0x%x, %p)\n", This, category, offload_capable);
1070
1071     if(!offload_capable)
1072         return E_INVALIDARG;
1073
1074     *offload_capable = FALSE;
1075
1076     return S_OK;
1077 }
1078
1079 static HRESULT WINAPI AudioClient_SetClientProperties(IAudioClient3 *iface,
1080         const AudioClientProperties *prop)
1081 {
1082     ACImpl *This = impl_from_IAudioClient3(iface);
1083     const Win8AudioClientProperties *legacy_prop = (const Win8AudioClientProperties *)prop;
1084
1085     TRACE("(%p)->(%p)\n", This, prop);
1086
1087     if(!legacy_prop)
1088         return E_POINTER;
1089
1090     if(legacy_prop->cbSize == sizeof(AudioClientProperties)){
1091         TRACE("{ bIsOffload: %u, eCategory: 0x%x, Options: 0x%x }\n",
1092                 legacy_prop->bIsOffload,
1093                 legacy_prop->eCategory,
1094                 prop->Options);
1095     }else if(legacy_prop->cbSize == sizeof(Win8AudioClientProperties)){
1096         TRACE("{ bIsOffload: %u, eCategory: 0x%x }\n",
1097                 legacy_prop->bIsOffload,
1098                 legacy_prop->eCategory);
1099     }else{
1100         WARN("Unsupported Size = %d\n", legacy_prop->cbSize);
1101         return E_INVALIDARG;
1102     }
1103
1104
1105     if(legacy_prop->bIsOffload)
1106         return AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE;
1107
1108     return S_OK;
1109 }
1110
1111 static HRESULT WINAPI AudioClient_GetBufferSizeLimits(IAudioClient3 *iface,
1112         const WAVEFORMATEX *format, BOOL event_driven, REFERENCE_TIME *min_duration,
1113         REFERENCE_TIME *max_duration)
1114 {
1115     ACImpl *This = impl_from_IAudioClient3(iface);
1116
1117     FIXME("(%p)->(%p, %u, %p, %p)\n", This, format, event_driven, min_duration, max_duration);
1118
1119     return E_NOTIMPL;
1120 }
1121
1122 static HRESULT WINAPI AudioClient_GetSharedModeEnginePeriod(IAudioClient3 *iface,
1123         const WAVEFORMATEX *format, UINT32 *default_period_frames, UINT32 *unit_period_frames,
1124         UINT32 *min_period_frames, UINT32 *max_period_frames)
1125 {
1126     ACImpl *This = impl_from_IAudioClient3(iface);
1127
1128     FIXME("(%p)->(%p, %p, %p, %p, %p)\n", This, format, default_period_frames, unit_period_frames,
1129             min_period_frames, max_period_frames);
1130
1131     return E_NOTIMPL;
1132 }
1133
1134 static HRESULT WINAPI AudioClient_GetCurrentSharedModeEnginePeriod(IAudioClient3 *iface,
1135         WAVEFORMATEX **cur_format, UINT32 *cur_period_frames)
1136 {
1137     ACImpl *This = impl_from_IAudioClient3(iface);
1138
1139     FIXME("(%p)->(%p, %p)\n", This, cur_format, cur_period_frames);
1140
1141     return E_NOTIMPL;
1142 }
1143
1144 static HRESULT WINAPI AudioClient_InitializeSharedAudioStream(IAudioClient3 *iface,
1145         DWORD flags, UINT32 period_frames, const WAVEFORMATEX *format,
1146         const GUID *session_guid)
1147 {
1148     ACImpl *This = impl_from_IAudioClient3(iface);
1149
1150     FIXME("(%p)->(0x%lx, %u, %p, %s)\n", This, flags, period_frames, format, debugstr_guid(session_guid));
1151
1152     return E_NOTIMPL;
1153 }
1154
1155 static const IAudioClient3Vtbl AudioClient3_Vtbl =
1156 {
1157     AudioClient_QueryInterface,
1158     AudioClient_AddRef,
1159     AudioClient_Release,
1160     AudioClient_Initialize,
1161     AudioClient_GetBufferSize,
1162     AudioClient_GetStreamLatency,
1163     AudioClient_GetCurrentPadding,
1164     AudioClient_IsFormatSupported,
1165     AudioClient_GetMixFormat,
1166     AudioClient_GetDevicePeriod,
1167     AudioClient_Start,
1168     AudioClient_Stop,
1169     AudioClient_Reset,
1170     AudioClient_SetEventHandle,
1171     AudioClient_GetService,
1172     AudioClient_IsOffloadCapable,
1173     AudioClient_SetClientProperties,
1174     AudioClient_GetBufferSizeLimits,
1175     AudioClient_GetSharedModeEnginePeriod,
1176     AudioClient_GetCurrentSharedModeEnginePeriod,
1177     AudioClient_InitializeSharedAudioStream,
1178 };
1179
1180 static HRESULT WINAPI AudioRenderClient_QueryInterface(
1181         IAudioRenderClient *iface, REFIID riid, void **ppv)
1182 {
1183     ACImpl *This = impl_from_IAudioRenderClient(iface);
1184     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1185
1186     if(!ppv)
1187         return E_POINTER;
1188     *ppv = NULL;
1189
1190     if(IsEqualIID(riid, &IID_IUnknown) ||
1191             IsEqualIID(riid, &IID_IAudioRenderClient))
1192         *ppv = iface;
1193     else if(IsEqualIID(riid, &IID_IMarshal))
1194         return IUnknown_QueryInterface(This->pUnkFTMarshal, riid, ppv);
1195     if(*ppv){
1196         IUnknown_AddRef((IUnknown*)*ppv);
1197         return S_OK;
1198     }
1199
1200     WARN("Unknown interface %s\n", debugstr_guid(riid));
1201     return E_NOINTERFACE;
1202 }
1203
1204 static ULONG WINAPI AudioRenderClient_AddRef(IAudioRenderClient *iface)
1205 {
1206     ACImpl *This = impl_from_IAudioRenderClient(iface);
1207     return AudioClient_AddRef(&This->IAudioClient3_iface);
1208 }
1209
1210 static ULONG WINAPI AudioRenderClient_Release(IAudioRenderClient *iface)
1211 {
1212     ACImpl *This = impl_from_IAudioRenderClient(iface);
1213     return AudioClient_Release(&This->IAudioClient3_iface);
1214 }
1215
1216 static HRESULT WINAPI AudioRenderClient_GetBuffer(IAudioRenderClient *iface,
1217         UINT32 frames, BYTE **data)
1218 {
1219     ACImpl *This = impl_from_IAudioRenderClient(iface);
1220     struct get_render_buffer_params params;
1221
1222     TRACE("(%p)->(%u, %p)\n", This, frames, data);
1223
1224     if(!data)
1225         return E_POINTER;
1226
1227     *data = NULL;
1228
1229     params.stream = This->stream;
1230     params.frames = frames;
1231     params.data = data;
1232     OSS_CALL(get_render_buffer, &params);
1233
1234     return params.result;
1235 }
1236
1237 static HRESULT WINAPI AudioRenderClient_ReleaseBuffer(
1238         IAudioRenderClient *iface, UINT32 written_frames, DWORD flags)
1239 {
1240     ACImpl *This = impl_from_IAudioRenderClient(iface);
1241     struct release_render_buffer_params params;
1242
1243     TRACE("(%p)->(%u, %lx)\n", This, written_frames, flags);
1244
1245     params.stream = This->stream;
1246     params.written_frames = written_frames;
1247     params.flags = flags;
1248     OSS_CALL(release_render_buffer, &params);
1249
1250     return params.result;
1251 }
1252
1253 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
1254     AudioRenderClient_QueryInterface,
1255     AudioRenderClient_AddRef,
1256     AudioRenderClient_Release,
1257     AudioRenderClient_GetBuffer,
1258     AudioRenderClient_ReleaseBuffer
1259 };
1260
1261 static HRESULT WINAPI AudioCaptureClient_QueryInterface(
1262         IAudioCaptureClient *iface, REFIID riid, void **ppv)
1263 {
1264     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1265     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1266
1267     if(!ppv)
1268         return E_POINTER;
1269     *ppv = NULL;
1270
1271     if(IsEqualIID(riid, &IID_IUnknown) ||
1272             IsEqualIID(riid, &IID_IAudioCaptureClient))
1273         *ppv = iface;
1274     else if(IsEqualIID(riid, &IID_IMarshal))
1275         return IUnknown_QueryInterface(This->pUnkFTMarshal, riid, ppv);
1276     if(*ppv){
1277         IUnknown_AddRef((IUnknown*)*ppv);
1278         return S_OK;
1279     }
1280
1281     WARN("Unknown interface %s\n", debugstr_guid(riid));
1282     return E_NOINTERFACE;
1283 }
1284
1285 static ULONG WINAPI AudioCaptureClient_AddRef(IAudioCaptureClient *iface)
1286 {
1287     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1288     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1289 }
1290
1291 static ULONG WINAPI AudioCaptureClient_Release(IAudioCaptureClient *iface)
1292 {
1293     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1294     return IAudioClient3_Release(&This->IAudioClient3_iface);
1295 }
1296
1297 static HRESULT WINAPI AudioCaptureClient_GetBuffer(IAudioCaptureClient *iface,
1298         BYTE **data, UINT32 *frames, DWORD *flags, UINT64 *devpos,
1299         UINT64 *qpcpos)
1300 {
1301     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1302     struct get_capture_buffer_params params;
1303
1304     TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags,
1305             devpos, qpcpos);
1306
1307     if(!data)
1308         return E_POINTER;
1309
1310     *data = NULL;
1311
1312     if(!frames || !flags)
1313         return E_POINTER;
1314
1315     params.stream = This->stream;
1316     params.data = data;
1317     params.frames = frames;
1318     params.flags = (UINT*)flags;
1319     params.devpos = devpos;
1320     params.qpcpos = qpcpos;
1321     OSS_CALL(get_capture_buffer, &params);
1322
1323     return params.result;
1324 }
1325
1326 static HRESULT WINAPI AudioCaptureClient_ReleaseBuffer(
1327         IAudioCaptureClient *iface, UINT32 done)
1328 {
1329     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1330     struct release_capture_buffer_params params;
1331
1332     TRACE("(%p)->(%u)\n", This, done);
1333
1334     params.stream = This->stream;
1335     params.done = done;
1336     OSS_CALL(release_capture_buffer, &params);
1337
1338     return params.result;
1339 }
1340
1341 static HRESULT WINAPI AudioCaptureClient_GetNextPacketSize(
1342         IAudioCaptureClient *iface, UINT32 *frames)
1343 {
1344     ACImpl *This = impl_from_IAudioCaptureClient(iface);
1345     struct get_next_packet_size_params params;
1346
1347     TRACE("(%p)->(%p)\n", This, frames);
1348
1349     if(!frames)
1350         return E_POINTER;
1351
1352     params.stream = This->stream;
1353     params.frames = frames;
1354     OSS_CALL(get_next_packet_size, &params);
1355
1356     return params.result;
1357 }
1358
1359 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
1360 {
1361     AudioCaptureClient_QueryInterface,
1362     AudioCaptureClient_AddRef,
1363     AudioCaptureClient_Release,
1364     AudioCaptureClient_GetBuffer,
1365     AudioCaptureClient_ReleaseBuffer,
1366     AudioCaptureClient_GetNextPacketSize
1367 };
1368
1369 static HRESULT WINAPI AudioClock_QueryInterface(IAudioClock *iface,
1370         REFIID riid, void **ppv)
1371 {
1372     ACImpl *This = impl_from_IAudioClock(iface);
1373
1374     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1375
1376     if(!ppv)
1377         return E_POINTER;
1378     *ppv = NULL;
1379
1380     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClock))
1381         *ppv = iface;
1382     else if(IsEqualIID(riid, &IID_IAudioClock2))
1383         *ppv = &This->IAudioClock2_iface;
1384     if(*ppv){
1385         IUnknown_AddRef((IUnknown*)*ppv);
1386         return S_OK;
1387     }
1388
1389     WARN("Unknown interface %s\n", debugstr_guid(riid));
1390     return E_NOINTERFACE;
1391 }
1392
1393 static ULONG WINAPI AudioClock_AddRef(IAudioClock *iface)
1394 {
1395     ACImpl *This = impl_from_IAudioClock(iface);
1396     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1397 }
1398
1399 static ULONG WINAPI AudioClock_Release(IAudioClock *iface)
1400 {
1401     ACImpl *This = impl_from_IAudioClock(iface);
1402     return IAudioClient3_Release(&This->IAudioClient3_iface);
1403 }
1404
1405 static HRESULT WINAPI AudioClock_GetFrequency(IAudioClock *iface, UINT64 *freq)
1406 {
1407     ACImpl *This = impl_from_IAudioClock(iface);
1408     struct get_frequency_params params;
1409
1410     TRACE("(%p)->(%p)\n", This, freq);
1411
1412     params.stream = This->stream;
1413     params.frequency = freq;
1414     OSS_CALL(get_frequency, &params);
1415
1416     return params.result;
1417 }
1418
1419 static HRESULT WINAPI AudioClock_GetPosition(IAudioClock *iface, UINT64 *pos,
1420         UINT64 *qpctime)
1421 {
1422     ACImpl *This = impl_from_IAudioClock(iface);
1423     struct get_position_params params;
1424
1425     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
1426
1427     if(!pos)
1428         return E_POINTER;
1429
1430     params.stream = This->stream;
1431     params.position = pos;
1432     params.qpctime = qpctime;
1433     OSS_CALL(get_position, &params);
1434
1435     return params.result;
1436 }
1437
1438 static HRESULT WINAPI AudioClock_GetCharacteristics(IAudioClock *iface,
1439         DWORD *chars)
1440 {
1441     ACImpl *This = impl_from_IAudioClock(iface);
1442
1443     TRACE("(%p)->(%p)\n", This, chars);
1444
1445     if(!chars)
1446         return E_POINTER;
1447
1448     *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
1449
1450     return S_OK;
1451 }
1452
1453 static const IAudioClockVtbl AudioClock_Vtbl =
1454 {
1455     AudioClock_QueryInterface,
1456     AudioClock_AddRef,
1457     AudioClock_Release,
1458     AudioClock_GetFrequency,
1459     AudioClock_GetPosition,
1460     AudioClock_GetCharacteristics
1461 };
1462
1463 static HRESULT WINAPI AudioClock2_QueryInterface(IAudioClock2 *iface,
1464         REFIID riid, void **ppv)
1465 {
1466     ACImpl *This = impl_from_IAudioClock2(iface);
1467     return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
1468 }
1469
1470 static ULONG WINAPI AudioClock2_AddRef(IAudioClock2 *iface)
1471 {
1472     ACImpl *This = impl_from_IAudioClock2(iface);
1473     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1474 }
1475
1476 static ULONG WINAPI AudioClock2_Release(IAudioClock2 *iface)
1477 {
1478     ACImpl *This = impl_from_IAudioClock2(iface);
1479     return IAudioClient3_Release(&This->IAudioClient3_iface);
1480 }
1481
1482 static HRESULT WINAPI AudioClock2_GetDevicePosition(IAudioClock2 *iface,
1483         UINT64 *pos, UINT64 *qpctime)
1484 {
1485     ACImpl *This = impl_from_IAudioClock2(iface);
1486
1487     FIXME("(%p)->(%p, %p)\n", This, pos, qpctime);
1488
1489     return E_NOTIMPL;
1490 }
1491
1492 static const IAudioClock2Vtbl AudioClock2_Vtbl =
1493 {
1494     AudioClock2_QueryInterface,
1495     AudioClock2_AddRef,
1496     AudioClock2_Release,
1497     AudioClock2_GetDevicePosition
1498 };
1499
1500 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client)
1501 {
1502     AudioSessionWrapper *ret;
1503
1504     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1505             sizeof(AudioSessionWrapper));
1506     if(!ret)
1507         return NULL;
1508
1509     ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
1510     ret->ISimpleAudioVolume_iface.lpVtbl = &SimpleAudioVolume_Vtbl;
1511     ret->IChannelAudioVolume_iface.lpVtbl = &ChannelAudioVolume_Vtbl;
1512
1513     ret->ref = 1;
1514
1515     ret->client = client;
1516     if(client){
1517         ret->session = client->session;
1518         AudioClient_AddRef(&client->IAudioClient3_iface);
1519     }
1520
1521     return ret;
1522 }
1523
1524 static HRESULT WINAPI AudioSessionControl_QueryInterface(
1525         IAudioSessionControl2 *iface, REFIID riid, void **ppv)
1526 {
1527     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1528
1529     if(!ppv)
1530         return E_POINTER;
1531     *ppv = NULL;
1532
1533     if(IsEqualIID(riid, &IID_IUnknown) ||
1534             IsEqualIID(riid, &IID_IAudioSessionControl) ||
1535             IsEqualIID(riid, &IID_IAudioSessionControl2))
1536         *ppv = iface;
1537     if(*ppv){
1538         IUnknown_AddRef((IUnknown*)*ppv);
1539         return S_OK;
1540     }
1541
1542     WARN("Unknown interface %s\n", debugstr_guid(riid));
1543     return E_NOINTERFACE;
1544 }
1545
1546 static ULONG WINAPI AudioSessionControl_AddRef(IAudioSessionControl2 *iface)
1547 {
1548     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1549     ULONG ref;
1550     ref = InterlockedIncrement(&This->ref);
1551     TRACE("(%p) Refcount now %lu\n", This, ref);
1552     return ref;
1553 }
1554
1555 static ULONG WINAPI AudioSessionControl_Release(IAudioSessionControl2 *iface)
1556 {
1557     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1558     ULONG ref;
1559     ref = InterlockedDecrement(&This->ref);
1560     TRACE("(%p) Refcount now %lu\n", This, ref);
1561     if(!ref){
1562         if(This->client){
1563             EnterCriticalSection(&g_sessions_lock);
1564             This->client->session_wrapper = NULL;
1565             LeaveCriticalSection(&g_sessions_lock);
1566             AudioClient_Release(&This->client->IAudioClient3_iface);
1567         }
1568         HeapFree(GetProcessHeap(), 0, This);
1569     }
1570     return ref;
1571 }
1572
1573 static HRESULT WINAPI AudioSessionControl_GetState(IAudioSessionControl2 *iface,
1574         AudioSessionState *state)
1575 {
1576     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1577     struct is_started_params params;
1578     ACImpl *client;
1579
1580     TRACE("(%p)->(%p)\n", This, state);
1581
1582     if(!state)
1583         return NULL_PTR_ERR;
1584
1585     EnterCriticalSection(&g_sessions_lock);
1586
1587     if(list_empty(&This->session->clients)){
1588         *state = AudioSessionStateExpired;
1589         LeaveCriticalSection(&g_sessions_lock);
1590         return S_OK;
1591     }
1592
1593     LIST_FOR_EACH_ENTRY(client, &This->session->clients, ACImpl, entry){
1594         params.stream = client->stream;
1595         OSS_CALL(is_started, &params);
1596         if(params.result == S_OK){
1597             *state = AudioSessionStateActive;
1598             LeaveCriticalSection(&g_sessions_lock);
1599             return S_OK;
1600         }
1601     }
1602
1603     LeaveCriticalSection(&g_sessions_lock);
1604
1605     *state = AudioSessionStateInactive;
1606
1607     return S_OK;
1608 }
1609
1610 static HRESULT WINAPI AudioSessionControl_GetDisplayName(
1611         IAudioSessionControl2 *iface, WCHAR **name)
1612 {
1613     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1614
1615     FIXME("(%p)->(%p) - stub\n", This, name);
1616
1617     return E_NOTIMPL;
1618 }
1619
1620 static HRESULT WINAPI AudioSessionControl_SetDisplayName(
1621         IAudioSessionControl2 *iface, const WCHAR *name, const GUID *session)
1622 {
1623     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1624
1625     FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
1626
1627     return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI AudioSessionControl_GetIconPath(
1631         IAudioSessionControl2 *iface, WCHAR **path)
1632 {
1633     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1634
1635     FIXME("(%p)->(%p) - stub\n", This, path);
1636
1637     return E_NOTIMPL;
1638 }
1639
1640 static HRESULT WINAPI AudioSessionControl_SetIconPath(
1641         IAudioSessionControl2 *iface, const WCHAR *path, const GUID *session)
1642 {
1643     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1644
1645     FIXME("(%p)->(%p, %s) - stub\n", This, path, debugstr_guid(session));
1646
1647     return E_NOTIMPL;
1648 }
1649
1650 static HRESULT WINAPI AudioSessionControl_GetGroupingParam(
1651         IAudioSessionControl2 *iface, GUID *group)
1652 {
1653     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1654
1655     FIXME("(%p)->(%p) - stub\n", This, group);
1656
1657     return E_NOTIMPL;
1658 }
1659
1660 static HRESULT WINAPI AudioSessionControl_SetGroupingParam(
1661         IAudioSessionControl2 *iface, const GUID *group, const GUID *session)
1662 {
1663     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1664
1665     FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group),
1666             debugstr_guid(session));
1667
1668     return E_NOTIMPL;
1669 }
1670
1671 static HRESULT WINAPI AudioSessionControl_RegisterAudioSessionNotification(
1672         IAudioSessionControl2 *iface, IAudioSessionEvents *events)
1673 {
1674     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1675
1676     FIXME("(%p)->(%p) - stub\n", This, events);
1677
1678     return S_OK;
1679 }
1680
1681 static HRESULT WINAPI AudioSessionControl_UnregisterAudioSessionNotification(
1682         IAudioSessionControl2 *iface, IAudioSessionEvents *events)
1683 {
1684     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1685
1686     FIXME("(%p)->(%p) - stub\n", This, events);
1687
1688     return S_OK;
1689 }
1690
1691 static HRESULT WINAPI AudioSessionControl_GetSessionIdentifier(
1692         IAudioSessionControl2 *iface, WCHAR **id)
1693 {
1694     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1695
1696     FIXME("(%p)->(%p) - stub\n", This, id);
1697
1698     return E_NOTIMPL;
1699 }
1700
1701 static HRESULT WINAPI AudioSessionControl_GetSessionInstanceIdentifier(
1702         IAudioSessionControl2 *iface, WCHAR **id)
1703 {
1704     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1705
1706     FIXME("(%p)->(%p) - stub\n", This, id);
1707
1708     return E_NOTIMPL;
1709 }
1710
1711 static HRESULT WINAPI AudioSessionControl_GetProcessId(
1712         IAudioSessionControl2 *iface, DWORD *pid)
1713 {
1714     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1715
1716     TRACE("(%p)->(%p)\n", This, pid);
1717
1718     if(!pid)
1719         return E_POINTER;
1720
1721     *pid = GetCurrentProcessId();
1722
1723     return S_OK;
1724 }
1725
1726 static HRESULT WINAPI AudioSessionControl_IsSystemSoundsSession(
1727         IAudioSessionControl2 *iface)
1728 {
1729     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1730
1731     TRACE("(%p)\n", This);
1732
1733     return S_FALSE;
1734 }
1735
1736 static HRESULT WINAPI AudioSessionControl_SetDuckingPreference(
1737         IAudioSessionControl2 *iface, BOOL optout)
1738 {
1739     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
1740
1741     TRACE("(%p)->(%d)\n", This, optout);
1742
1743     return S_OK;
1744 }
1745
1746 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
1747 {
1748     AudioSessionControl_QueryInterface,
1749     AudioSessionControl_AddRef,
1750     AudioSessionControl_Release,
1751     AudioSessionControl_GetState,
1752     AudioSessionControl_GetDisplayName,
1753     AudioSessionControl_SetDisplayName,
1754     AudioSessionControl_GetIconPath,
1755     AudioSessionControl_SetIconPath,
1756     AudioSessionControl_GetGroupingParam,
1757     AudioSessionControl_SetGroupingParam,
1758     AudioSessionControl_RegisterAudioSessionNotification,
1759     AudioSessionControl_UnregisterAudioSessionNotification,
1760     AudioSessionControl_GetSessionIdentifier,
1761     AudioSessionControl_GetSessionInstanceIdentifier,
1762     AudioSessionControl_GetProcessId,
1763     AudioSessionControl_IsSystemSoundsSession,
1764     AudioSessionControl_SetDuckingPreference
1765 };
1766
1767 static HRESULT WINAPI SimpleAudioVolume_QueryInterface(
1768         ISimpleAudioVolume *iface, REFIID riid, void **ppv)
1769 {
1770     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1771
1772     if(!ppv)
1773         return E_POINTER;
1774     *ppv = NULL;
1775
1776     if(IsEqualIID(riid, &IID_IUnknown) ||
1777             IsEqualIID(riid, &IID_ISimpleAudioVolume))
1778         *ppv = iface;
1779     if(*ppv){
1780         IUnknown_AddRef((IUnknown*)*ppv);
1781         return S_OK;
1782     }
1783
1784     WARN("Unknown interface %s\n", debugstr_guid(riid));
1785     return E_NOINTERFACE;
1786 }
1787
1788 static ULONG WINAPI SimpleAudioVolume_AddRef(ISimpleAudioVolume *iface)
1789 {
1790     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
1791     return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
1792 }
1793
1794 static ULONG WINAPI SimpleAudioVolume_Release(ISimpleAudioVolume *iface)
1795 {
1796     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
1797     return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
1798 }
1799
1800 static HRESULT WINAPI SimpleAudioVolume_SetMasterVolume(
1801         ISimpleAudioVolume *iface, float level, const GUID *context)
1802 {
1803     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
1804     AudioSession *session = This->session;
1805     ACImpl *client;
1806
1807     TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
1808
1809     if(level < 0.f || level > 1.f)
1810         return E_INVALIDARG;
1811
1812     if(context)
1813         FIXME("Notifications not supported yet\n");
1814
1815     EnterCriticalSection(&g_sessions_lock);
1816
1817     session->master_vol = level;
1818
1819     TRACE("OSS doesn't support setting volume\n");
1820     LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry)
1821         set_stream_volumes(client);
1822
1823     LeaveCriticalSection(&g_sessions_lock);
1824
1825     return S_OK;
1826 }
1827
1828 static HRESULT WINAPI SimpleAudioVolume_GetMasterVolume(
1829         ISimpleAudioVolume *iface, float *level)
1830 {
1831     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
1832     AudioSession *session = This->session;
1833
1834     TRACE("(%p)->(%p)\n", session, level);
1835
1836     if(!level)
1837         return NULL_PTR_ERR;
1838
1839     *level = session->master_vol;
1840
1841     return S_OK;
1842 }
1843
1844 static HRESULT WINAPI SimpleAudioVolume_SetMute(ISimpleAudioVolume *iface,
1845         BOOL mute, const GUID *context)
1846 {
1847     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
1848     AudioSession *session = This->session;
1849     ACImpl *client;
1850
1851     TRACE("(%p)->(%u, %s)\n", session, mute, debugstr_guid(context));
1852
1853     EnterCriticalSection(&g_sessions_lock);
1854
1855     session->mute = mute;
1856
1857     LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry)
1858         set_stream_volumes(client);
1859
1860     LeaveCriticalSection(&g_sessions_lock);
1861
1862     return S_OK;
1863 }
1864
1865 static HRESULT WINAPI SimpleAudioVolume_GetMute(ISimpleAudioVolume *iface,
1866         BOOL *mute)
1867 {
1868     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
1869     AudioSession *session = This->session;
1870
1871     TRACE("(%p)->(%p)\n", session, mute);
1872
1873     if(!mute)
1874         return NULL_PTR_ERR;
1875
1876     *mute = This->session->mute;
1877
1878     return S_OK;
1879 }
1880
1881 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl  =
1882 {
1883     SimpleAudioVolume_QueryInterface,
1884     SimpleAudioVolume_AddRef,
1885     SimpleAudioVolume_Release,
1886     SimpleAudioVolume_SetMasterVolume,
1887     SimpleAudioVolume_GetMasterVolume,
1888     SimpleAudioVolume_SetMute,
1889     SimpleAudioVolume_GetMute
1890 };
1891
1892 static HRESULT WINAPI AudioStreamVolume_QueryInterface(
1893         IAudioStreamVolume *iface, REFIID riid, void **ppv)
1894 {
1895     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1896
1897     if(!ppv)
1898         return E_POINTER;
1899     *ppv = NULL;
1900
1901     if(IsEqualIID(riid, &IID_IUnknown) ||
1902             IsEqualIID(riid, &IID_IAudioStreamVolume))
1903         *ppv = iface;
1904     if(*ppv){
1905         IUnknown_AddRef((IUnknown*)*ppv);
1906         return S_OK;
1907     }
1908
1909     WARN("Unknown interface %s\n", debugstr_guid(riid));
1910     return E_NOINTERFACE;
1911 }
1912
1913 static ULONG WINAPI AudioStreamVolume_AddRef(IAudioStreamVolume *iface)
1914 {
1915     ACImpl *This = impl_from_IAudioStreamVolume(iface);
1916     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1917 }
1918
1919 static ULONG WINAPI AudioStreamVolume_Release(IAudioStreamVolume *iface)
1920 {
1921     ACImpl *This = impl_from_IAudioStreamVolume(iface);
1922     return IAudioClient3_Release(&This->IAudioClient3_iface);
1923 }
1924
1925 static HRESULT WINAPI AudioStreamVolume_GetChannelCount(
1926         IAudioStreamVolume *iface, UINT32 *out)
1927 {
1928     ACImpl *This = impl_from_IAudioStreamVolume(iface);
1929
1930     TRACE("(%p)->(%p)\n", This, out);
1931
1932     if(!out)
1933         return E_POINTER;
1934
1935     *out = This->channel_count;
1936
1937     return S_OK;
1938 }
1939
1940 static HRESULT WINAPI AudioStreamVolume_SetChannelVolume(
1941         IAudioStreamVolume *iface, UINT32 index, float level)
1942 {
1943     ACImpl *This = impl_from_IAudioStreamVolume(iface);
1944
1945     TRACE("(%p)->(%d, %f)\n", This, index, level);
1946
1947     if(level < 0.f || level > 1.f)
1948         return E_INVALIDARG;
1949
1950     if(index >= This->channel_count)
1951         return E_INVALIDARG;
1952
1953     EnterCriticalSection(&g_sessions_lock);
1954
1955     This->vols[index] = level;
1956
1957     TRACE("OSS doesn't support setting volume\n");
1958     set_stream_volumes(This);
1959
1960     LeaveCriticalSection(&g_sessions_lock);
1961
1962     return S_OK;
1963 }
1964
1965 static HRESULT WINAPI AudioStreamVolume_GetChannelVolume(
1966         IAudioStreamVolume *iface, UINT32 index, float *level)
1967 {
1968     ACImpl *This = impl_from_IAudioStreamVolume(iface);
1969
1970     TRACE("(%p)->(%d, %p)\n", This, index, level);
1971
1972     if(!level)
1973         return E_POINTER;
1974
1975     if(index >= This->channel_count)
1976         return E_INVALIDARG;
1977
1978     *level = This->vols[index];
1979
1980     return S_OK;
1981 }
1982
1983 static HRESULT WINAPI AudioStreamVolume_SetAllVolumes(
1984         IAudioStreamVolume *iface, UINT32 count, const float *levels)
1985 {
1986     ACImpl *This = impl_from_IAudioStreamVolume(iface);
1987     int i;
1988
1989     TRACE("(%p)->(%d, %p)\n", This, count, levels);
1990
1991     if(!levels)
1992         return E_POINTER;
1993
1994     if(count != This->channel_count)
1995         return E_INVALIDARG;
1996
1997     EnterCriticalSection(&g_sessions_lock);
1998
1999     for(i = 0; i < count; ++i)
2000         This->vols[i] = levels[i];
2001
2002     TRACE("OSS doesn't support setting volume\n");
2003     set_stream_volumes(This);
2004
2005     LeaveCriticalSection(&g_sessions_lock);
2006
2007     return S_OK;
2008 }
2009
2010 static HRESULT WINAPI AudioStreamVolume_GetAllVolumes(
2011         IAudioStreamVolume *iface, UINT32 count, float *levels)
2012 {
2013     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2014     int i;
2015
2016     TRACE("(%p)->(%d, %p)\n", This, count, levels);
2017
2018     if(!levels)
2019         return E_POINTER;
2020
2021     if(count != This->channel_count)
2022         return E_INVALIDARG;
2023
2024     EnterCriticalSection(&g_sessions_lock);
2025
2026     for(i = 0; i < count; ++i)
2027         levels[i] = This->vols[i];
2028
2029     LeaveCriticalSection(&g_sessions_lock);
2030
2031     return S_OK;
2032 }
2033
2034 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
2035 {
2036     AudioStreamVolume_QueryInterface,
2037     AudioStreamVolume_AddRef,
2038     AudioStreamVolume_Release,
2039     AudioStreamVolume_GetChannelCount,
2040     AudioStreamVolume_SetChannelVolume,
2041     AudioStreamVolume_GetChannelVolume,
2042     AudioStreamVolume_SetAllVolumes,
2043     AudioStreamVolume_GetAllVolumes
2044 };
2045
2046 static HRESULT WINAPI ChannelAudioVolume_QueryInterface(
2047         IChannelAudioVolume *iface, REFIID riid, void **ppv)
2048 {
2049     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2050
2051     if(!ppv)
2052         return E_POINTER;
2053     *ppv = NULL;
2054
2055     if(IsEqualIID(riid, &IID_IUnknown) ||
2056             IsEqualIID(riid, &IID_IChannelAudioVolume))
2057         *ppv = iface;
2058     if(*ppv){
2059         IUnknown_AddRef((IUnknown*)*ppv);
2060         return S_OK;
2061     }
2062
2063     WARN("Unknown interface %s\n", debugstr_guid(riid));
2064     return E_NOINTERFACE;
2065 }
2066
2067 static ULONG WINAPI ChannelAudioVolume_AddRef(IChannelAudioVolume *iface)
2068 {
2069     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2070     return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
2071 }
2072
2073 static ULONG WINAPI ChannelAudioVolume_Release(IChannelAudioVolume *iface)
2074 {
2075     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2076     return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
2077 }
2078
2079 static HRESULT WINAPI ChannelAudioVolume_GetChannelCount(
2080         IChannelAudioVolume *iface, UINT32 *out)
2081 {
2082     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2083     AudioSession *session = This->session;
2084
2085     TRACE("(%p)->(%p)\n", session, out);
2086
2087     if(!out)
2088         return NULL_PTR_ERR;
2089
2090     *out = session->channel_count;
2091
2092     return S_OK;
2093 }
2094
2095 static HRESULT WINAPI ChannelAudioVolume_SetChannelVolume(
2096         IChannelAudioVolume *iface, UINT32 index, float level,
2097         const GUID *context)
2098 {
2099     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2100     AudioSession *session = This->session;
2101     ACImpl *client;
2102
2103     TRACE("(%p)->(%d, %f, %s)\n", session, index, level,
2104             wine_dbgstr_guid(context));
2105
2106     if(level < 0.f || level > 1.f)
2107         return E_INVALIDARG;
2108
2109     if(index >= session->channel_count)
2110         return E_INVALIDARG;
2111
2112     if(context)
2113         FIXME("Notifications not supported yet\n");
2114
2115     EnterCriticalSection(&g_sessions_lock);
2116
2117     session->channel_vols[index] = level;
2118
2119     TRACE("OSS doesn't support setting volume\n");
2120     LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry)
2121         set_stream_volumes(client);
2122
2123     LeaveCriticalSection(&g_sessions_lock);
2124
2125     return S_OK;
2126 }
2127
2128 static HRESULT WINAPI ChannelAudioVolume_GetChannelVolume(
2129         IChannelAudioVolume *iface, UINT32 index, float *level)
2130 {
2131     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2132     AudioSession *session = This->session;
2133
2134     TRACE("(%p)->(%d, %p)\n", session, index, level);
2135
2136     if(!level)
2137         return NULL_PTR_ERR;
2138
2139     if(index >= session->channel_count)
2140         return E_INVALIDARG;
2141
2142     *level = session->channel_vols[index];
2143
2144     return S_OK;
2145 }
2146
2147 static HRESULT WINAPI ChannelAudioVolume_SetAllVolumes(
2148         IChannelAudioVolume *iface, UINT32 count, const float *levels,
2149         const GUID *context)
2150 {
2151     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2152     AudioSession *session = This->session;
2153     ACImpl *client;
2154     int i;
2155
2156     TRACE("(%p)->(%d, %p, %s)\n", session, count, levels,
2157             wine_dbgstr_guid(context));
2158
2159     if(!levels)
2160         return NULL_PTR_ERR;
2161
2162     if(count != session->channel_count)
2163         return E_INVALIDARG;
2164
2165     if(context)
2166         FIXME("Notifications not supported yet\n");
2167
2168     EnterCriticalSection(&g_sessions_lock);
2169
2170     for(i = 0; i < count; ++i)
2171         session->channel_vols[i] = levels[i];
2172
2173     TRACE("OSS doesn't support setting volume\n");
2174     LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry)
2175         set_stream_volumes(client);
2176
2177     LeaveCriticalSection(&g_sessions_lock);
2178
2179     return S_OK;
2180 }
2181
2182 static HRESULT WINAPI ChannelAudioVolume_GetAllVolumes(
2183         IChannelAudioVolume *iface, UINT32 count, float *levels)
2184 {
2185     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2186     AudioSession *session = This->session;
2187     int i;
2188
2189     TRACE("(%p)->(%d, %p)\n", session, count, levels);
2190
2191     if(!levels)
2192         return NULL_PTR_ERR;
2193
2194     if(count != session->channel_count)
2195         return E_INVALIDARG;
2196
2197     for(i = 0; i < count; ++i)
2198         levels[i] = session->channel_vols[i];
2199
2200     return S_OK;
2201 }
2202
2203 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
2204 {
2205     ChannelAudioVolume_QueryInterface,
2206     ChannelAudioVolume_AddRef,
2207     ChannelAudioVolume_Release,
2208     ChannelAudioVolume_GetChannelCount,
2209     ChannelAudioVolume_SetChannelVolume,
2210     ChannelAudioVolume_GetChannelVolume,
2211     ChannelAudioVolume_SetAllVolumes,
2212     ChannelAudioVolume_GetAllVolumes
2213 };
2214
2215 static HRESULT WINAPI AudioSessionManager_QueryInterface(IAudioSessionManager2 *iface,
2216         REFIID riid, void **ppv)
2217 {
2218     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2219
2220     if(!ppv)
2221         return E_POINTER;
2222     *ppv = NULL;
2223
2224     if(IsEqualIID(riid, &IID_IUnknown) ||
2225             IsEqualIID(riid, &IID_IAudioSessionManager) ||
2226             IsEqualIID(riid, &IID_IAudioSessionManager2))
2227         *ppv = iface;
2228     if(*ppv){
2229         IUnknown_AddRef((IUnknown*)*ppv);
2230         return S_OK;
2231     }
2232
2233     WARN("Unknown interface %s\n", debugstr_guid(riid));
2234     return E_NOINTERFACE;
2235 }
2236
2237 static ULONG WINAPI AudioSessionManager_AddRef(IAudioSessionManager2 *iface)
2238 {
2239     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2240     ULONG ref;
2241     ref = InterlockedIncrement(&This->ref);
2242     TRACE("(%p) Refcount now %lu\n", This, ref);
2243     return ref;
2244 }
2245
2246 static ULONG WINAPI AudioSessionManager_Release(IAudioSessionManager2 *iface)
2247 {
2248     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2249     ULONG ref;
2250     ref = InterlockedDecrement(&This->ref);
2251     TRACE("(%p) Refcount now %lu\n", This, ref);
2252     if(!ref)
2253         HeapFree(GetProcessHeap(), 0, This);
2254     return ref;
2255 }
2256
2257 static HRESULT WINAPI AudioSessionManager_GetAudioSessionControl(
2258         IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
2259         IAudioSessionControl **out)
2260 {
2261     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2262     AudioSession *session;
2263     AudioSessionWrapper *wrapper;
2264     HRESULT hr;
2265
2266     TRACE("(%p)->(%s, %lx, %p)\n", This, debugstr_guid(session_guid),
2267             flags, out);
2268
2269     hr = get_audio_session(session_guid, This->device, 0, &session);
2270     if(FAILED(hr))
2271         return hr;
2272
2273     wrapper = AudioSessionWrapper_Create(NULL);
2274     if(!wrapper)
2275         return E_OUTOFMEMORY;
2276
2277     wrapper->session = session;
2278
2279     *out = (IAudioSessionControl*)&wrapper->IAudioSessionControl2_iface;
2280
2281     return S_OK;
2282 }
2283
2284 static HRESULT WINAPI AudioSessionManager_GetSimpleAudioVolume(
2285         IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
2286         ISimpleAudioVolume **out)
2287 {
2288     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2289     AudioSession *session;
2290     AudioSessionWrapper *wrapper;
2291     HRESULT hr;
2292
2293     TRACE("(%p)->(%s, %lx, %p)\n", This, debugstr_guid(session_guid),
2294             flags, out);
2295
2296     hr = get_audio_session(session_guid, This->device, 0, &session);
2297     if(FAILED(hr))
2298         return hr;
2299
2300     wrapper = AudioSessionWrapper_Create(NULL);
2301     if(!wrapper)
2302         return E_OUTOFMEMORY;
2303
2304     wrapper->session = session;
2305
2306     *out = &wrapper->ISimpleAudioVolume_iface;
2307
2308     return S_OK;
2309 }
2310
2311 static HRESULT WINAPI AudioSessionManager_GetSessionEnumerator(
2312         IAudioSessionManager2 *iface, IAudioSessionEnumerator **out)
2313 {
2314     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2315     FIXME("(%p)->(%p) - stub\n", This, out);
2316     return E_NOTIMPL;
2317 }
2318
2319 static HRESULT WINAPI AudioSessionManager_RegisterSessionNotification(
2320         IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
2321 {
2322     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2323     FIXME("(%p)->(%p) - stub\n", This, notification);
2324     return E_NOTIMPL;
2325 }
2326
2327 static HRESULT WINAPI AudioSessionManager_UnregisterSessionNotification(
2328         IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
2329 {
2330     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2331     FIXME("(%p)->(%p) - stub\n", This, notification);
2332     return E_NOTIMPL;
2333 }
2334
2335 static HRESULT WINAPI AudioSessionManager_RegisterDuckNotification(
2336         IAudioSessionManager2 *iface, const WCHAR *session_id,
2337         IAudioVolumeDuckNotification *notification)
2338 {
2339     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2340     FIXME("(%p)->(%p) - stub\n", This, notification);
2341     return E_NOTIMPL;
2342 }
2343
2344 static HRESULT WINAPI AudioSessionManager_UnregisterDuckNotification(
2345         IAudioSessionManager2 *iface,
2346         IAudioVolumeDuckNotification *notification)
2347 {
2348     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2349     FIXME("(%p)->(%p) - stub\n", This, notification);
2350     return E_NOTIMPL;
2351 }
2352
2353 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl =
2354 {
2355     AudioSessionManager_QueryInterface,
2356     AudioSessionManager_AddRef,
2357     AudioSessionManager_Release,
2358     AudioSessionManager_GetAudioSessionControl,
2359     AudioSessionManager_GetSimpleAudioVolume,
2360     AudioSessionManager_GetSessionEnumerator,
2361     AudioSessionManager_RegisterSessionNotification,
2362     AudioSessionManager_UnregisterSessionNotification,
2363     AudioSessionManager_RegisterDuckNotification,
2364     AudioSessionManager_UnregisterDuckNotification
2365 };
2366
2367 HRESULT WINAPI AUDDRV_GetAudioSessionManager(IMMDevice *device,
2368         IAudioSessionManager2 **out)
2369 {
2370     SessionMgr *This;
2371
2372     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SessionMgr));
2373     if(!This)
2374         return E_OUTOFMEMORY;
2375
2376     This->IAudioSessionManager2_iface.lpVtbl = &AudioSessionManager2_Vtbl;
2377     This->device = device;
2378     This->ref = 1;
2379
2380     *out = &This->IAudioSessionManager2_iface;
2381
2382     return S_OK;
2383 }