dlls/wineoss.drv/mmdevdrv.c

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