git.oblomov.eu Git - wine/blob - dlls/winealsa.drv/mmdevdrv.c

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