dlls/mmdevapi/spatialaudio.c

   1 /*
   2  * Copyright 2020 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 COBJMACROS
  20 #define NONAMELESSUNION
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winnls.h"
  27 #include "winreg.h"
  28 #include "wine/heap.h"
  29 #include "wine/debug.h"
  30 #include "wine/list.h"
  31
  32 #include "ole2.h"
  33 #include "mmdeviceapi.h"
  34 #include "mmsystem.h"
  35 #include "audioclient.h"
  36 #include "endpointvolume.h"
  37 #include "audiopolicy.h"
  38 #include "spatialaudioclient.h"
  39
  40 #include "mmdevapi.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  43
  44 static UINT32 AudioObjectType_to_index(AudioObjectType type)
  45 {
  46     UINT32 o = 0;
  47     while(type){
  48         type >>= 1;
  49         ++o;
  50     }
  51     return o - 2;
  52 }
  53
  54 typedef struct SpatialAudioImpl SpatialAudioImpl;
  55 typedef struct SpatialAudioStreamImpl SpatialAudioStreamImpl;
  56 typedef struct SpatialAudioObjectImpl SpatialAudioObjectImpl;
  57
  58 struct SpatialAudioObjectImpl {
  59     ISpatialAudioObject ISpatialAudioObject_iface;
  60     LONG ref;
  61
  62     SpatialAudioStreamImpl *sa_stream;
  63     AudioObjectType type;
  64     UINT32 static_idx;
  65
  66     float *buf;
  67
  68     struct list entry;
  69 };
  70
  71 struct SpatialAudioStreamImpl {
  72     ISpatialAudioObjectRenderStream ISpatialAudioObjectRenderStream_iface;
  73     LONG ref;
  74     CRITICAL_SECTION lock;
  75
  76     SpatialAudioImpl *sa_client;
  77     SpatialAudioObjectRenderStreamActivationParams params;
  78
  79     IAudioClient *client;
  80     IAudioRenderClient *render;
  81
  82     UINT32 period_frames, update_frames;
  83     WAVEFORMATEXTENSIBLE stream_fmtex;
  84
  85     float *buf;
  86
  87     UINT32 static_object_map[17];
  88
  89     struct list objects;
  90 };
  91
  92 struct SpatialAudioImpl {
  93     ISpatialAudioClient ISpatialAudioClient_iface;
  94     IAudioFormatEnumerator IAudioFormatEnumerator_iface;
  95     IMMDevice *mmdev;
  96     LONG ref;
  97     WAVEFORMATEXTENSIBLE object_fmtex;
  98 };
  99
 100 static inline SpatialAudioObjectImpl *impl_from_ISpatialAudioObject(ISpatialAudioObject *iface)
 101 {
 102     return CONTAINING_RECORD(iface, SpatialAudioObjectImpl, ISpatialAudioObject_iface);
 103 }
 104
 105 static inline SpatialAudioStreamImpl *impl_from_ISpatialAudioObjectRenderStream(ISpatialAudioObjectRenderStream *iface)
 106 {
 107     return CONTAINING_RECORD(iface, SpatialAudioStreamImpl, ISpatialAudioObjectRenderStream_iface);
 108 }
 109
 110 static inline SpatialAudioImpl *impl_from_ISpatialAudioClient(ISpatialAudioClient *iface)
 111 {
 112     return CONTAINING_RECORD(iface, SpatialAudioImpl, ISpatialAudioClient_iface);
 113 }
 114
 115 static inline SpatialAudioImpl *impl_from_IAudioFormatEnumerator(IAudioFormatEnumerator *iface)
 116 {
 117     return CONTAINING_RECORD(iface, SpatialAudioImpl, IAudioFormatEnumerator_iface);
 118 }
 119
 120 static HRESULT WINAPI SAO_QueryInterface(ISpatialAudioObject *iface,
 121         REFIID riid, void **ppv)
 122 {
 123     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 124
 125     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 126
 127     if (!ppv)
 128         return E_POINTER;
 129
 130     *ppv = NULL;
 131
 132     if (IsEqualIID(riid, &IID_IUnknown) ||
 133             IsEqualIID(riid, &IID_ISpatialAudioObjectBase) ||
 134             IsEqualIID(riid, &IID_ISpatialAudioObject)) {
 135         *ppv = &This->ISpatialAudioObject_iface;
 136     }
 137     else
 138         return E_NOINTERFACE;
 139
 140     IUnknown_AddRef((IUnknown *)*ppv);
 141
 142     return S_OK;
 143 }
 144
 145 static ULONG WINAPI SAO_AddRef(ISpatialAudioObject *iface)
 146 {
 147     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 148     ULONG ref = InterlockedIncrement(&This->ref);
 149     TRACE("(%p) new ref %u\n", This, ref);
 150     return ref;
 151 }
 152
 153 static ULONG WINAPI SAO_Release(ISpatialAudioObject *iface)
 154 {
 155     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 156     ULONG ref = InterlockedDecrement(&This->ref);
 157     TRACE("(%p) new ref %u\n", This, ref);
 158     if(!ref){
 159         EnterCriticalSection(&This->sa_stream->lock);
 160         list_remove(&This->entry);
 161         LeaveCriticalSection(&This->sa_stream->lock);
 162
 163         ISpatialAudioObjectRenderStream_Release(&This->sa_stream->ISpatialAudioObjectRenderStream_iface);
 164         heap_free(This->buf);
 165         heap_free(This);
 166     }
 167     return ref;
 168 }
 169
 170 static HRESULT WINAPI SAO_GetBuffer(ISpatialAudioObject *iface,
 171         BYTE **buffer, UINT32 *bytes)
 172 {
 173     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 174
 175     TRACE("(%p)->(%p, %p)\n", This, buffer, bytes);
 176
 177     EnterCriticalSection(&This->sa_stream->lock);
 178
 179     if(This->sa_stream->update_frames == ~0){
 180         LeaveCriticalSection(&This->sa_stream->lock);
 181         return SPTLAUDCLNT_E_OUT_OF_ORDER;
 182     }
 183
 184     *buffer = (BYTE *)This->buf;
 185     *bytes = This->sa_stream->update_frames *
 186         This->sa_stream->sa_client->object_fmtex.Format.nBlockAlign;
 187
 188     LeaveCriticalSection(&This->sa_stream->lock);
 189
 190     return S_OK;
 191 }
 192
 193 static HRESULT WINAPI SAO_SetEndOfStream(ISpatialAudioObject *iface, UINT32 frames)
 194 {
 195     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 196     FIXME("(%p)->(%u)\n", This, frames);
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI SAO_IsActive(ISpatialAudioObject *iface, BOOL *active)
 201 {
 202     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 203     FIXME("(%p)->(%p)\n", This, active);
 204     return E_NOTIMPL;
 205 }
 206
 207 static HRESULT WINAPI SAO_GetAudioObjectType(ISpatialAudioObject *iface,
 208         AudioObjectType *type)
 209 {
 210     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 211
 212     TRACE("(%p)->(%p)\n", This, type);
 213
 214     *type = This->type;
 215
 216     return S_OK;
 217 }
 218
 219 static HRESULT WINAPI SAO_SetPosition(ISpatialAudioObject *iface, float x,
 220         float y, float z)
 221 {
 222     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 223     FIXME("(%p)->(%f, %f, %f)\n", This, x, y, z);
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI SAO_SetVolume(ISpatialAudioObject *iface, float vol)
 228 {
 229     SpatialAudioObjectImpl *This = impl_from_ISpatialAudioObject(iface);
 230     FIXME("(%p)->(%f)\n", This, vol);
 231     return E_NOTIMPL;
 232 }
 233
 234 static ISpatialAudioObjectVtbl ISpatialAudioObject_vtbl = {
 235     SAO_QueryInterface,
 236     SAO_AddRef,
 237     SAO_Release,
 238     SAO_GetBuffer,
 239     SAO_SetEndOfStream,
 240     SAO_IsActive,
 241     SAO_GetAudioObjectType,
 242     SAO_SetPosition,
 243     SAO_SetVolume,
 244 };
 245
 246 static HRESULT WINAPI SAORS_QueryInterface(ISpatialAudioObjectRenderStream *iface,
 247         REFIID riid, void **ppv)
 248 {
 249     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 250
 251     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 252
 253     if (!ppv)
 254         return E_POINTER;
 255
 256     *ppv = NULL;
 257
 258     if (IsEqualIID(riid, &IID_IUnknown) ||
 259             IsEqualIID(riid, &IID_ISpatialAudioObjectRenderStreamBase) ||
 260             IsEqualIID(riid, &IID_ISpatialAudioObjectRenderStream)) {
 261         *ppv = &This->ISpatialAudioObjectRenderStream_iface;
 262     }
 263     else
 264         return E_NOINTERFACE;
 265
 266     IUnknown_AddRef((IUnknown *)*ppv);
 267
 268     return S_OK;
 269 }
 270
 271 static ULONG WINAPI SAORS_AddRef(ISpatialAudioObjectRenderStream *iface)
 272 {
 273     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 274     ULONG ref = InterlockedIncrement(&This->ref);
 275     TRACE("(%p) new ref %u\n", This, ref);
 276     return ref;
 277 }
 278
 279 static ULONG WINAPI SAORS_Release(ISpatialAudioObjectRenderStream *iface)
 280 {
 281     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 282     ULONG ref = InterlockedDecrement(&This->ref);
 283     TRACE("(%p) new ref %u\n", This, ref);
 284     if(!ref){
 285         IAudioClient_Stop(This->client);
 286         if(This->update_frames != ~0 && This->update_frames > 0)
 287             IAudioRenderClient_ReleaseBuffer(This->render, This->update_frames, 0);
 288         IAudioRenderClient_Release(This->render);
 289         IAudioClient_Release(This->client);
 290         if(This->params.NotifyObject)
 291             ISpatialAudioObjectRenderStreamNotify_Release(This->params.NotifyObject);
 292         heap_free((void*)This->params.ObjectFormat);
 293         CloseHandle(This->params.EventHandle);
 294         DeleteCriticalSection(&This->lock);
 295         ISpatialAudioClient_Release(&This->sa_client->ISpatialAudioClient_iface);
 296         heap_free(This);
 297     }
 298     return ref;
 299 }
 300
 301 static HRESULT WINAPI SAORS_GetAvailableDynamicObjectCount(
 302         ISpatialAudioObjectRenderStream *iface, UINT32 *count)
 303 {
 304     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 305     FIXME("(%p)->(%p)\n", This, count);
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI SAORS_GetService(ISpatialAudioObjectRenderStream *iface,
 310         REFIID riid, void **service)
 311 {
 312     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 313     FIXME("(%p)->(%s, %p)\n", This, debugstr_guid(riid), service);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI SAORS_Start(ISpatialAudioObjectRenderStream *iface)
 318 {
 319     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 320     HRESULT hr;
 321
 322     TRACE("(%p)->()\n", This);
 323
 324     hr = IAudioClient_Start(This->client);
 325     if(FAILED(hr)){
 326         WARN("IAudioClient::Start failed: %08x\n", hr);
 327         return hr;
 328     }
 329
 330     return S_OK;
 331 }
 332
 333 static HRESULT WINAPI SAORS_Stop(ISpatialAudioObjectRenderStream *iface)
 334 {
 335     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 336     HRESULT hr;
 337
 338     TRACE("(%p)->()\n", This);
 339
 340     hr = IAudioClient_Stop(This->client);
 341     if(FAILED(hr)){
 342         WARN("IAudioClient::Stop failed: %08x\n", hr);
 343         return hr;
 344     }
 345
 346     return S_OK;
 347 }
 348
 349 static HRESULT WINAPI SAORS_Reset(ISpatialAudioObjectRenderStream *iface)
 350 {
 351     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 352     FIXME("(%p)->()\n", This);
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI SAORS_BeginUpdatingAudioObjects(ISpatialAudioObjectRenderStream *iface,
 357         UINT32 *dyn_count, UINT32 *frames)
 358 {
 359     static BOOL fixme_once = FALSE;
 360     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 361     SpatialAudioObjectImpl *object;
 362     HRESULT hr;
 363
 364     TRACE("(%p)->(%p, %p)\n", This, dyn_count, frames);
 365
 366     EnterCriticalSection(&This->lock);
 367
 368     if(This->update_frames != ~0){
 369         LeaveCriticalSection(&This->lock);
 370         return SPTLAUDCLNT_E_OUT_OF_ORDER;
 371     }
 372
 373     This->update_frames = This->period_frames;
 374
 375     if(This->update_frames > 0){
 376         hr = IAudioRenderClient_GetBuffer(This->render, This->update_frames, (BYTE **)&This->buf);
 377         if(FAILED(hr)){
 378             WARN("GetBuffer failed: %08x\n", hr);
 379             This->update_frames = ~0;
 380             LeaveCriticalSection(&This->lock);
 381             return hr;
 382         }
 383
 384         LIST_FOR_EACH_ENTRY(object, &This->objects, SpatialAudioObjectImpl, entry){
 385             memset(object->buf, 0, This->update_frames * This->sa_client->object_fmtex.Format.nBlockAlign);
 386         }
 387     }else if (!fixme_once){
 388         fixme_once = TRUE;
 389         FIXME("Zero frame update.\n");
 390     }
 391
 392     *dyn_count = 0;
 393     *frames = This->update_frames;
 394
 395     LeaveCriticalSection(&This->lock);
 396
 397     return S_OK;
 398 }
 399
 400 static void mix_static_object(SpatialAudioStreamImpl *stream, SpatialAudioObjectImpl *object)
 401 {
 402     float *in = object->buf, *out;
 403     UINT32 i;
 404     if(object->static_idx == ~0 ||
 405             stream->static_object_map[object->static_idx] == ~0){
 406         WARN("Got unmapped static object?! Not mixing. Type: 0x%x\n", object->type);
 407         return;
 408     }
 409     out = stream->buf + stream->static_object_map[object->static_idx];
 410     for(i = 0; i < stream->update_frames; ++i){
 411         *out += *in;
 412         ++in;
 413         out += stream->stream_fmtex.Format.nChannels;
 414     }
 415 }
 416
 417 static HRESULT WINAPI SAORS_EndUpdatingAudioObjects(ISpatialAudioObjectRenderStream *iface)
 418 {
 419     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 420     SpatialAudioObjectImpl *object;
 421     HRESULT hr;
 422
 423     TRACE("(%p)->()\n", This);
 424
 425     EnterCriticalSection(&This->lock);
 426
 427     if(This->update_frames == ~0){
 428         LeaveCriticalSection(&This->lock);
 429         return SPTLAUDCLNT_E_OUT_OF_ORDER;
 430     }
 431
 432     if(This->update_frames > 0){
 433         LIST_FOR_EACH_ENTRY(object, &This->objects, SpatialAudioObjectImpl, entry){
 434             if(object->type != AudioObjectType_Dynamic)
 435                 mix_static_object(This, object);
 436             else
 437                 WARN("Don't know how to mix dynamic object yet. %p\n", object);
 438         }
 439
 440         hr = IAudioRenderClient_ReleaseBuffer(This->render, This->update_frames, 0);
 441         if(FAILED(hr))
 442             WARN("ReleaseBuffer failed: %08x\n", hr);
 443     }
 444
 445     This->update_frames = ~0;
 446
 447     LeaveCriticalSection(&This->lock);
 448
 449     return S_OK;
 450 }
 451
 452 static HRESULT WINAPI SAORS_ActivateSpatialAudioObject(ISpatialAudioObjectRenderStream *iface,
 453         AudioObjectType type, ISpatialAudioObject **object)
 454 {
 455     SpatialAudioStreamImpl *This = impl_from_ISpatialAudioObjectRenderStream(iface);
 456     SpatialAudioObjectImpl *obj;
 457
 458     TRACE("(%p)->(0x%x, %p)\n", This, type, object);
 459
 460     if(type == AudioObjectType_Dynamic)
 461         return SPTLAUDCLNT_E_NO_MORE_OBJECTS;
 462
 463     if(type & ~This->params.StaticObjectTypeMask)
 464         return SPTLAUDCLNT_E_STATIC_OBJECT_NOT_AVAILABLE;
 465
 466     LIST_FOR_EACH_ENTRY(obj, &This->objects, SpatialAudioObjectImpl, entry){
 467         if(obj->static_idx == AudioObjectType_to_index(type))
 468             return SPTLAUDCLNT_E_OBJECT_ALREADY_ACTIVE;
 469     }
 470
 471     obj = heap_alloc_zero(sizeof(*obj));
 472     obj->ISpatialAudioObject_iface.lpVtbl = &ISpatialAudioObject_vtbl;
 473     obj->ref = 1;
 474     obj->type = type;
 475     if(type == AudioObjectType_None){
 476         FIXME("AudioObjectType_None not implemented yet!\n");
 477         obj->static_idx = ~0;
 478     }else{
 479         obj->static_idx = AudioObjectType_to_index(type);
 480     }
 481
 482     obj->sa_stream = This;
 483     SAORS_AddRef(&This->ISpatialAudioObjectRenderStream_iface);
 484
 485     obj->buf = heap_alloc_zero(This->period_frames * This->sa_client->object_fmtex.Format.nBlockAlign);
 486
 487     EnterCriticalSection(&This->lock);
 488
 489     list_add_tail(&This->objects, &obj->entry);
 490
 491     LeaveCriticalSection(&This->lock);
 492
 493     *object = &obj->ISpatialAudioObject_iface;
 494
 495     return S_OK;
 496 }
 497
 498 static ISpatialAudioObjectRenderStreamVtbl ISpatialAudioObjectRenderStream_vtbl = {
 499     SAORS_QueryInterface,
 500     SAORS_AddRef,
 501     SAORS_Release,
 502     SAORS_GetAvailableDynamicObjectCount,
 503     SAORS_GetService,
 504     SAORS_Start,
 505     SAORS_Stop,
 506     SAORS_Reset,
 507     SAORS_BeginUpdatingAudioObjects,
 508     SAORS_EndUpdatingAudioObjects,
 509     SAORS_ActivateSpatialAudioObject,
 510 };
 511
 512 static HRESULT WINAPI SAC_QueryInterface(ISpatialAudioClient *iface, REFIID riid, void **ppv)
 513 {
 514     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 515
 516     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 517
 518     if (!ppv)
 519         return E_POINTER;
 520
 521     *ppv = NULL;
 522
 523     if (IsEqualIID(riid, &IID_IUnknown) ||
 524             IsEqualIID(riid, &IID_ISpatialAudioClient)) {
 525         *ppv = &This->ISpatialAudioClient_iface;
 526     }
 527     else
 528         return E_NOINTERFACE;
 529
 530     IUnknown_AddRef((IUnknown *)*ppv);
 531
 532     return S_OK;
 533 }
 534
 535 static ULONG WINAPI SAC_AddRef(ISpatialAudioClient *iface)
 536 {
 537     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 538     ULONG ref = InterlockedIncrement(&This->ref);
 539     TRACE("(%p) new ref %u\n", This, ref);
 540     return ref;
 541 }
 542
 543 static ULONG WINAPI SAC_Release(ISpatialAudioClient *iface)
 544 {
 545     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 546     ULONG ref = InterlockedDecrement(&This->ref);
 547     TRACE("(%p) new ref %u\n", This, ref);
 548     if (!ref) {
 549         IMMDevice_Release(This->mmdev);
 550         heap_free(This);
 551     }
 552     return ref;
 553 }
 554
 555 static HRESULT WINAPI SAC_GetStaticObjectPosition(ISpatialAudioClient *iface,
 556         AudioObjectType type, float *x, float *y, float *z)
 557 {
 558     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 559     FIXME("(%p)->(0x%x, %p, %p, %p)\n", This, type, x, y, z);
 560     return E_NOTIMPL;
 561 }
 562
 563 static HRESULT WINAPI SAC_GetNativeStaticObjectTypeMask(ISpatialAudioClient *iface,
 564         AudioObjectType *mask)
 565 {
 566     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 567     FIXME("(%p)->(%p)\n", This, mask);
 568     return E_NOTIMPL;
 569 }
 570
 571 static HRESULT WINAPI SAC_GetMaxDynamicObjectCount(ISpatialAudioClient *iface,
 572         UINT32 *value)
 573 {
 574     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 575     FIXME("(%p)->(%p)\n", This, value);
 576
 577     *value = 0;
 578
 579     return S_OK;
 580 }
 581
 582 static HRESULT WINAPI SAC_GetSupportedAudioObjectFormatEnumerator(
 583         ISpatialAudioClient *iface, IAudioFormatEnumerator **enumerator)
 584 {
 585     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 586
 587     TRACE("(%p)->(%p)\n", This, enumerator);
 588
 589     *enumerator = &This->IAudioFormatEnumerator_iface;
 590     SAC_AddRef(iface);
 591
 592     return S_OK;
 593 }
 594
 595 static HRESULT WINAPI SAC_GetMaxFrameCount(ISpatialAudioClient *iface,
 596         const WAVEFORMATEX *format, UINT32 *count)
 597 {
 598     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 599
 600     /* FIXME: should get device period from the device */
 601     static const REFERENCE_TIME period = 100000;
 602
 603     TRACE("(%p)->(%p, %p)\n", This, format, count);
 604
 605     *count = MulDiv(period, format->nSamplesPerSec, 10000000);
 606
 607     return S_OK;
 608 }
 609
 610 static HRESULT WINAPI SAC_IsAudioObjectFormatSupported(ISpatialAudioClient *iface,
 611         const WAVEFORMATEX *format)
 612 {
 613     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 614     FIXME("(%p)->(%p)\n", This, format);
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI SAC_IsSpatialAudioStreamAvailable(ISpatialAudioClient *iface,
 619         REFIID stream_uuid, const PROPVARIANT *info)
 620 {
 621     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 622     FIXME("(%p)->(%s, %p)\n", This, debugstr_guid(stream_uuid), info);
 623     return E_NOTIMPL;
 624 }
 625
 626 static WAVEFORMATEX *clone_fmtex(const WAVEFORMATEX *src)
 627 {
 628     WAVEFORMATEX *r = heap_alloc(sizeof(WAVEFORMATEX) + src->cbSize);
 629     memcpy(r, src, sizeof(WAVEFORMATEX) + src->cbSize);
 630     return r;
 631 }
 632
 633 static const char *debugstr_fmtex(const WAVEFORMATEX *fmt)
 634 {
 635     static char buf[2048];
 636     if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
 637         const WAVEFORMATEXTENSIBLE *fmtex = (const WAVEFORMATEXTENSIBLE *)fmt;
 638         snprintf(buf, sizeof(buf), "tag: 0x%x (%s), ch: %u (mask: 0x%x), rate: %u, depth: %u",
 639                 fmt->wFormatTag, debugstr_guid(&fmtex->SubFormat),
 640                 fmt->nChannels, fmtex->dwChannelMask, fmt->nSamplesPerSec,
 641                 fmt->wBitsPerSample);
 642     }else{
 643         snprintf(buf, sizeof(buf), "tag: 0x%x, ch: %u, rate: %u, depth: %u",
 644                 fmt->wFormatTag, fmt->nChannels, fmt->nSamplesPerSec,
 645                 fmt->wBitsPerSample);
 646     }
 647     return buf;
 648 }
 649
 650 static void static_mask_to_channels(AudioObjectType static_mask, WORD *count, DWORD *mask, UINT32 *map)
 651 {
 652     UINT32 out_chan = 0, map_idx = 0;
 653     *count = 0;
 654     *mask = 0;
 655 #define CONVERT_MASK(f, t) \
 656     if(static_mask & f){ \
 657         *count += 1; \
 658         *mask |= t; \
 659         map[map_idx++] = out_chan++; \
 660         TRACE("mapping 0x%x to %u\n", f, out_chan - 1); \
 661     }else{ \
 662         map[map_idx++] = ~0; \
 663     }
 664     CONVERT_MASK(AudioObjectType_FrontLeft, SPEAKER_FRONT_LEFT);
 665     CONVERT_MASK(AudioObjectType_FrontRight, SPEAKER_FRONT_RIGHT);
 666     CONVERT_MASK(AudioObjectType_FrontCenter, SPEAKER_FRONT_CENTER);
 667     CONVERT_MASK(AudioObjectType_LowFrequency, SPEAKER_LOW_FREQUENCY);
 668     CONVERT_MASK(AudioObjectType_SideLeft, SPEAKER_SIDE_LEFT);
 669     CONVERT_MASK(AudioObjectType_SideRight, SPEAKER_SIDE_RIGHT);
 670     CONVERT_MASK(AudioObjectType_BackLeft, SPEAKER_BACK_LEFT);
 671     CONVERT_MASK(AudioObjectType_BackRight, SPEAKER_BACK_RIGHT);
 672     CONVERT_MASK(AudioObjectType_TopFrontLeft, SPEAKER_TOP_FRONT_LEFT);
 673     CONVERT_MASK(AudioObjectType_TopFrontRight, SPEAKER_TOP_FRONT_RIGHT);
 674     CONVERT_MASK(AudioObjectType_TopBackLeft, SPEAKER_TOP_BACK_LEFT);
 675     CONVERT_MASK(AudioObjectType_TopBackRight, SPEAKER_TOP_BACK_RIGHT);
 676     CONVERT_MASK(AudioObjectType_BackCenter, SPEAKER_BACK_CENTER);
 677 }
 678
 679 static HRESULT activate_stream(SpatialAudioStreamImpl *stream)
 680 {
 681     WAVEFORMATEXTENSIBLE *object_fmtex = (WAVEFORMATEXTENSIBLE *)stream->params.ObjectFormat;
 682     HRESULT hr;
 683     REFERENCE_TIME period;
 684
 685     if(!(object_fmtex->Format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
 686                 (object_fmtex->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 687                  IsEqualGUID(&object_fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)))){
 688         FIXME("Only float formats are supported for now\n");
 689         return E_INVALIDARG;
 690     }
 691
 692     hr = IMMDevice_Activate(stream->sa_client->mmdev, &IID_IAudioClient,
 693             CLSCTX_INPROC_SERVER, NULL, (void**)&stream->client);
 694     if(FAILED(hr)){
 695         WARN("Activate failed: %08x\n", hr);
 696         return hr;
 697     }
 698
 699     hr = IAudioClient_GetDevicePeriod(stream->client, &period, NULL);
 700     if(FAILED(hr)){
 701         WARN("GetDevicePeriod failed: %08x\n", hr);
 702         IAudioClient_Release(stream->client);
 703         return hr;
 704     }
 705
 706     stream->stream_fmtex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 707     static_mask_to_channels(stream->params.StaticObjectTypeMask,
 708             &stream->stream_fmtex.Format.nChannels, &stream->stream_fmtex.dwChannelMask,
 709             stream->static_object_map);
 710     stream->stream_fmtex.Format.nSamplesPerSec = stream->params.ObjectFormat->nSamplesPerSec;
 711     stream->stream_fmtex.Format.wBitsPerSample = stream->params.ObjectFormat->wBitsPerSample;
 712     stream->stream_fmtex.Format.nBlockAlign = (stream->stream_fmtex.Format.nChannels * stream->stream_fmtex.Format.wBitsPerSample) / 8;
 713     stream->stream_fmtex.Format.nAvgBytesPerSec = stream->stream_fmtex.Format.nSamplesPerSec * stream->stream_fmtex.Format.nBlockAlign;
 714     stream->stream_fmtex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 715     stream->stream_fmtex.Samples.wValidBitsPerSample = stream->stream_fmtex.Format.wBitsPerSample;
 716     stream->stream_fmtex.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 717
 718     hr = IAudioClient_Initialize(stream->client, AUDCLNT_SHAREMODE_SHARED,
 719             AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
 720             period, 0, &stream->stream_fmtex.Format, NULL);
 721     if(FAILED(hr)){
 722         WARN("Initialize failed: %08x\n", hr);
 723         IAudioClient_Release(stream->client);
 724         return hr;
 725     }
 726
 727     hr = IAudioClient_SetEventHandle(stream->client, stream->params.EventHandle);
 728     if(FAILED(hr)){
 729         WARN("SetEventHandle failed: %08x\n", hr);
 730         IAudioClient_Release(stream->client);
 731         return hr;
 732     }
 733
 734     hr = IAudioClient_GetService(stream->client, &IID_IAudioRenderClient, (void**)&stream->render);
 735     if(FAILED(hr)){
 736         WARN("GetService(AudioRenderClient) failed: %08x\n", hr);
 737         IAudioClient_Release(stream->client);
 738         return hr;
 739     }
 740
 741     stream->period_frames = MulDiv(period, stream->stream_fmtex.Format.nSamplesPerSec, 10000000);
 742
 743     return S_OK;
 744 }
 745
 746 static HRESULT WINAPI SAC_ActivateSpatialAudioStream(ISpatialAudioClient *iface,
 747         const PROPVARIANT *prop, REFIID riid, void **stream)
 748 {
 749     SpatialAudioImpl *This = impl_from_ISpatialAudioClient(iface);
 750     SpatialAudioObjectRenderStreamActivationParams *params;
 751     HRESULT hr;
 752
 753     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), stream);
 754
 755     if(IsEqualIID(riid, &IID_ISpatialAudioObjectRenderStream)){
 756         SpatialAudioStreamImpl *obj;
 757
 758         if(prop &&
 759                 (prop->vt != VT_BLOB ||
 760                  prop->u.blob.cbSize != sizeof(SpatialAudioObjectRenderStreamActivationParams))){
 761             WARN("Got invalid params\n");
 762             *stream = NULL;
 763             return E_INVALIDARG;
 764         }
 765
 766         params = (SpatialAudioObjectRenderStreamActivationParams*) prop->u.blob.pBlobData;
 767
 768         if(params->StaticObjectTypeMask & AudioObjectType_Dynamic){
 769             *stream = NULL;
 770             return E_INVALIDARG;
 771         }
 772
 773         if(params->EventHandle == INVALID_HANDLE_VALUE ||
 774                 params->EventHandle == 0){
 775             *stream = NULL;
 776             return E_INVALIDARG;
 777         }
 778
 779         if(!params->ObjectFormat ||
 780                 memcmp(params->ObjectFormat, &This->object_fmtex.Format, sizeof(*params->ObjectFormat) + params->ObjectFormat->cbSize)){
 781             *stream = NULL;
 782             return AUDCLNT_E_UNSUPPORTED_FORMAT;
 783         }
 784
 785         obj = heap_alloc_zero(sizeof(SpatialAudioStreamImpl));
 786
 787         obj->ISpatialAudioObjectRenderStream_iface.lpVtbl = &ISpatialAudioObjectRenderStream_vtbl;
 788         obj->ref = 1;
 789         memcpy(&obj->params, params, sizeof(obj->params));
 790
 791         obj->update_frames = ~0;
 792
 793         InitializeCriticalSection(&obj->lock);
 794         list_init(&obj->objects);
 795
 796         obj->sa_client = This;
 797         SAC_AddRef(&This->ISpatialAudioClient_iface);
 798
 799         obj->params.ObjectFormat = clone_fmtex(obj->params.ObjectFormat);
 800
 801         DuplicateHandle(GetCurrentProcess(), obj->params.EventHandle,
 802                 GetCurrentProcess(), &obj->params.EventHandle, 0, FALSE,
 803                 DUPLICATE_SAME_ACCESS);
 804
 805         if(obj->params.NotifyObject)
 806             ISpatialAudioObjectRenderStreamNotify_AddRef(obj->params.NotifyObject);
 807
 808         if(TRACE_ON(mmdevapi)){
 809             TRACE("ObjectFormat: {%s}\n", debugstr_fmtex(obj->params.ObjectFormat));
 810             TRACE("StaticObjectTypeMask: 0x%x\n", obj->params.StaticObjectTypeMask);
 811             TRACE("MinDynamicObjectCount: 0x%x\n", obj->params.MinDynamicObjectCount);
 812             TRACE("MaxDynamicObjectCount: 0x%x\n", obj->params.MaxDynamicObjectCount);
 813             TRACE("Category: 0x%x\n", obj->params.Category);
 814             TRACE("EventHandle: %p\n", obj->params.EventHandle);
 815             TRACE("NotifyObject: %p\n", obj->params.NotifyObject);
 816         }
 817
 818         hr = activate_stream(obj);
 819         if(FAILED(hr)){
 820             if(obj->params.NotifyObject)
 821                 ISpatialAudioObjectRenderStreamNotify_Release(obj->params.NotifyObject);
 822             DeleteCriticalSection(&obj->lock);
 823             heap_free((void*)obj->params.ObjectFormat);
 824             CloseHandle(obj->params.EventHandle);
 825             ISpatialAudioClient_Release(&obj->sa_client->ISpatialAudioClient_iface);
 826             heap_free(obj);
 827             *stream = NULL;
 828             return hr;
 829         }
 830
 831         *stream = &obj->ISpatialAudioObjectRenderStream_iface;
 832     }else{
 833         FIXME("Unsupported audio stream IID: %s\n", debugstr_guid(riid));
 834         *stream = NULL;
 835         return E_NOTIMPL;
 836     }
 837
 838     return S_OK;
 839 }
 840
 841 static ISpatialAudioClientVtbl ISpatialAudioClient_vtbl = {
 842     SAC_QueryInterface,
 843     SAC_AddRef,
 844     SAC_Release,
 845     SAC_GetStaticObjectPosition,
 846     SAC_GetNativeStaticObjectTypeMask,
 847     SAC_GetMaxDynamicObjectCount,
 848     SAC_GetSupportedAudioObjectFormatEnumerator,
 849     SAC_GetMaxFrameCount,
 850     SAC_IsAudioObjectFormatSupported,
 851     SAC_IsSpatialAudioStreamAvailable,
 852     SAC_ActivateSpatialAudioStream,
 853 };
 854
 855 static HRESULT WINAPI SAOFE_QueryInterface(IAudioFormatEnumerator *iface,
 856         REFIID riid, void **ppvObject)
 857 {
 858     SpatialAudioImpl *This = impl_from_IAudioFormatEnumerator(iface);
 859     return SAC_QueryInterface(&This->ISpatialAudioClient_iface, riid, ppvObject);
 860 }
 861
 862 static ULONG WINAPI SAOFE_AddRef(IAudioFormatEnumerator *iface)
 863 {
 864     SpatialAudioImpl *This = impl_from_IAudioFormatEnumerator(iface);
 865     return SAC_AddRef(&This->ISpatialAudioClient_iface);
 866 }
 867
 868 static ULONG WINAPI SAOFE_Release(IAudioFormatEnumerator *iface)
 869 {
 870     SpatialAudioImpl *This = impl_from_IAudioFormatEnumerator(iface);
 871     return SAC_Release(&This->ISpatialAudioClient_iface);
 872 }
 873
 874 static HRESULT WINAPI SAOFE_GetCount(IAudioFormatEnumerator *iface, UINT32 *count)
 875 {
 876     SpatialAudioImpl *This = impl_from_IAudioFormatEnumerator(iface);
 877
 878     TRACE("(%p)->(%p)\n", This, count);
 879
 880     *count = 1;
 881
 882     return S_OK;
 883 }
 884
 885 static HRESULT WINAPI SAOFE_GetFormat(IAudioFormatEnumerator *iface,
 886         UINT32 index, WAVEFORMATEX **format)
 887 {
 888     SpatialAudioImpl *This = impl_from_IAudioFormatEnumerator(iface);
 889
 890     TRACE("(%p)->(%u, %p)\n", This, index, format);
 891
 892     if(index > 0)
 893         return E_INVALIDARG;
 894
 895     *format = &This->object_fmtex.Format;
 896
 897     return S_OK;
 898 }
 899
 900 static IAudioFormatEnumeratorVtbl IAudioFormatEnumerator_vtbl = {
 901     SAOFE_QueryInterface,
 902     SAOFE_AddRef,
 903     SAOFE_Release,
 904     SAOFE_GetCount,
 905     SAOFE_GetFormat,
 906 };
 907
 908 HRESULT SpatialAudioClient_Create(IMMDevice *mmdev, ISpatialAudioClient **out)
 909 {
 910     SpatialAudioImpl *obj;
 911     IAudioClient *aclient;
 912     WAVEFORMATEX *closest;
 913     HRESULT hr;
 914
 915     obj = heap_alloc_zero(sizeof(*obj));
 916
 917     obj->ref = 1;
 918     obj->ISpatialAudioClient_iface.lpVtbl = &ISpatialAudioClient_vtbl;
 919     obj->IAudioFormatEnumerator_iface.lpVtbl = &IAudioFormatEnumerator_vtbl;
 920
 921     obj->object_fmtex.Format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
 922     obj->object_fmtex.Format.nChannels = 1;
 923     obj->object_fmtex.Format.nSamplesPerSec = 48000;
 924     obj->object_fmtex.Format.wBitsPerSample = sizeof(float) * 8;
 925     obj->object_fmtex.Format.nBlockAlign = (obj->object_fmtex.Format.nChannels * obj->object_fmtex.Format.wBitsPerSample) / 8;
 926     obj->object_fmtex.Format.nAvgBytesPerSec = obj->object_fmtex.Format.nSamplesPerSec * obj->object_fmtex.Format.nBlockAlign;
 927     obj->object_fmtex.Format.cbSize = 0;
 928
 929     hr = IMMDevice_Activate(mmdev, &IID_IAudioClient,
 930             CLSCTX_INPROC_SERVER, NULL, (void**)&aclient);
 931     if(FAILED(hr)){
 932         WARN("Activate failed: %08x\n", hr);
 933         heap_free(obj);
 934         return hr;
 935     }
 936
 937     hr = IAudioClient_IsFormatSupported(aclient, AUDCLNT_SHAREMODE_SHARED, &obj->object_fmtex.Format, &closest);
 938
 939     IAudioClient_Release(aclient);
 940
 941     if(hr == S_FALSE){
 942         if(sizeof(WAVEFORMATEX) + closest->cbSize > sizeof(obj->object_fmtex)){
 943             ERR("Returned format too large: %s\n", debugstr_fmtex(closest));
 944             CoTaskMemFree(closest);
 945             heap_free(obj);
 946             return AUDCLNT_E_UNSUPPORTED_FORMAT;
 947         }else if(!((closest->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
 948                     (closest->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
 949                      IsEqualGUID(&((WAVEFORMATEXTENSIBLE *)closest)->SubFormat,
 950                          &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))) &&
 951                     closest->wBitsPerSample == 32)){
 952             ERR("Returned format not 32-bit float: %s\n", debugstr_fmtex(closest));
 953             CoTaskMemFree(closest);
 954             heap_free(obj);
 955             return AUDCLNT_E_UNSUPPORTED_FORMAT;
 956         }
 957         WARN("The audio stack doesn't support 48kHz 32bit float. Using the closest match. Audio may be glitchy. %s\n", debugstr_fmtex(closest));
 958         memcpy(&obj->object_fmtex,
 959                closest,
 960                sizeof(WAVEFORMATEX) + closest->cbSize);
 961         CoTaskMemFree(closest);
 962     } else if(hr != S_OK){
 963         WARN("Checking supported formats failed: %08x\n", hr);
 964         heap_free(obj);
 965         return hr;
 966     }
 967
 968     obj->mmdev = mmdev;
 969     IMMDevice_AddRef(mmdev);
 970
 971     *out = &obj->ISpatialAudioClient_iface;
 972
 973     return S_OK;
 974 }