dlls/wineandroid.drv/mmdevdrv.c

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