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