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