dlls/wineoss.drv/mmdevdrv.c

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