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