dlls/mmdevapi/client.c

   1 /*
   2  * Copyright 2011-2012 Maarten Lankhorst
   3  * Copyright 2010-2011 Maarten Lankhorst for CodeWeavers
   4  * Copyright 2011 Andrew Eikum for CodeWeavers
   5  * Copyright 2022 Huw Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include <wchar.h>
  25
  26 #include <audiopolicy.h>
  27 #include <mmdeviceapi.h>
  28 #include <winternl.h>
  29
  30 #include <wine/debug.h>
  31 #include <wine/unixlib.h>
  32
  33 #include "mmdevapi_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  36
  37 typedef struct tagLANGANDCODEPAGE
  38 {
  39     WORD wLanguage;
  40     WORD wCodePage;
  41 } LANGANDCODEPAGE;
  42
  43 extern void sessions_lock(void) DECLSPEC_HIDDEN;
  44 extern void sessions_unlock(void) DECLSPEC_HIDDEN;
  45
  46 extern HRESULT get_audio_session(const GUID *sessionguid, IMMDevice *device, UINT channels,
  47                                  struct audio_session **out) DECLSPEC_HIDDEN;
  48 extern struct audio_session_wrapper *session_wrapper_create(struct audio_client *client) DECLSPEC_HIDDEN;
  49
  50 static HANDLE main_loop_thread;
  51
  52 void main_loop_stop(void)
  53 {
  54     if (main_loop_thread) {
  55         WaitForSingleObject(main_loop_thread, INFINITE);
  56         CloseHandle(main_loop_thread);
  57     }
  58 }
  59
  60 void set_stream_volumes(struct audio_client *This)
  61 {
  62     struct set_volumes_params params;
  63
  64     params.stream          = This->stream;
  65     params.master_volume   = (This->session->mute ? 0.0f : This->session->master_vol);
  66     params.volumes         = This->vols;
  67     params.session_volumes = This->session->channel_vols;
  68
  69     wine_unix_call(set_volumes, &params);
  70 }
  71
  72 static inline struct audio_client *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
  73 {
  74     return CONTAINING_RECORD(iface, struct audio_client, IAudioCaptureClient_iface);
  75 }
  76
  77 static inline struct audio_client *impl_from_IAudioClient3(IAudioClient3 *iface)
  78 {
  79     return CONTAINING_RECORD(iface, struct audio_client, IAudioClient3_iface);
  80 }
  81
  82 static inline struct audio_client *impl_from_IAudioClock(IAudioClock *iface)
  83 {
  84     return CONTAINING_RECORD(iface, struct audio_client, IAudioClock_iface);
  85 }
  86
  87 static inline struct audio_client *impl_from_IAudioClock2(IAudioClock2 *iface)
  88 {
  89     return CONTAINING_RECORD(iface, struct audio_client, IAudioClock2_iface);
  90 }
  91
  92 static inline struct audio_client *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
  93 {
  94     return CONTAINING_RECORD(iface, struct audio_client, IAudioRenderClient_iface);
  95 }
  96
  97 static inline struct audio_client *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
  98 {
  99     return CONTAINING_RECORD(iface, struct audio_client, IAudioStreamVolume_iface);
 100 }
 101
 102 static void dump_fmt(const WAVEFORMATEX *fmt)
 103 {
 104     TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
 105     switch (fmt->wFormatTag) {
 106         case WAVE_FORMAT_PCM:
 107             TRACE("WAVE_FORMAT_PCM");
 108             break;
 109         case WAVE_FORMAT_IEEE_FLOAT:
 110             TRACE("WAVE_FORMAT_IEEE_FLOAT");
 111             break;
 112         case WAVE_FORMAT_EXTENSIBLE:
 113             TRACE("WAVE_FORMAT_EXTENSIBLE");
 114             break;
 115         default:
 116             TRACE("Unknown");
 117             break;
 118     }
 119     TRACE(")\n");
 120
 121     TRACE("nChannels: %u\n", fmt->nChannels);
 122     TRACE("nSamplesPerSec: %lu\n", fmt->nSamplesPerSec);
 123     TRACE("nAvgBytesPerSec: %lu\n", fmt->nAvgBytesPerSec);
 124     TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
 125     TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
 126     TRACE("cbSize: %u\n", fmt->cbSize);
 127
 128     if (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
 129         WAVEFORMATEXTENSIBLE *fmtex = (void *)fmt;
 130         TRACE("dwChannelMask: %08lx\n", fmtex->dwChannelMask);
 131         TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
 132         TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
 133     }
 134 }
 135
 136 static DWORD CALLBACK main_loop_func(void *event)
 137 {
 138     struct main_loop_params params;
 139
 140     SetThreadDescription(GetCurrentThread(), L"audio_client_main");
 141
 142     params.event = event;
 143
 144     wine_unix_call(main_loop, &params);
 145
 146     return 0;
 147 }
 148
 149 HRESULT main_loop_start(void)
 150 {
 151     if (!main_loop_thread) {
 152         HANDLE event = CreateEventW(NULL, TRUE, FALSE, NULL);
 153         if (!(main_loop_thread = CreateThread(NULL, 0, main_loop_func, event, 0, NULL))) {
 154             ERR("Failed to create main loop thread\n");
 155             CloseHandle(event);
 156             return E_FAIL;
 157         }
 158
 159         SetThreadPriority(main_loop_thread, THREAD_PRIORITY_TIME_CRITICAL);
 160         WaitForSingleObject(event, INFINITE);
 161         CloseHandle(event);
 162     }
 163
 164     return S_OK;
 165 }
 166
 167 static DWORD CALLBACK timer_loop_func(void *user)
 168 {
 169     struct timer_loop_params params;
 170     struct audio_client *This = user;
 171
 172     SetThreadDescription(GetCurrentThread(), L"audio_client_timer");
 173
 174     params.stream = This->stream;
 175
 176     wine_unix_call(timer_loop, &params);
 177
 178     return 0;
 179 }
 180
 181 HRESULT stream_release(stream_handle stream, HANDLE timer_thread)
 182 {
 183     struct release_stream_params params;
 184
 185     params.stream       = stream;
 186     params.timer_thread = timer_thread;
 187
 188     wine_unix_call(release_stream, &params);
 189
 190     return params.result;
 191 }
 192
 193 static BOOL query_productname(void *data, LANGANDCODEPAGE *lang, LPVOID *buffer, UINT *len)
 194 {
 195     WCHAR pn[37];
 196     swprintf(pn, ARRAY_SIZE(pn), L"\\StringFileInfo\\%04x%04x\\ProductName", lang->wLanguage, lang->wCodePage);
 197     return VerQueryValueW(data, pn, buffer, len) && *len;
 198 }
 199
 200 WCHAR *get_application_name(void)
 201 {
 202     WCHAR path[MAX_PATH], *name;
 203     UINT translate_size, productname_size;
 204     LANGANDCODEPAGE *translate;
 205     LPVOID productname;
 206     BOOL found = FALSE;
 207     void *data = NULL;
 208     unsigned int i;
 209     LCID locale;
 210     DWORD size;
 211
 212     GetModuleFileNameW(NULL, path, ARRAY_SIZE(path));
 213
 214     size = GetFileVersionInfoSizeW(path, NULL);
 215     if (!size)
 216         goto skip;
 217
 218     data = malloc(size);
 219     if (!data)
 220         goto skip;
 221
 222     if (!GetFileVersionInfoW(path, 0, size, data))
 223         goto skip;
 224
 225     if (!VerQueryValueW(data, L"\\VarFileInfo\\Translation", (LPVOID *)&translate, &translate_size))
 226         goto skip;
 227
 228     /* No translations found. */
 229     if (translate_size < sizeof(LANGANDCODEPAGE))
 230         goto skip;
 231
 232     /* The following code will try to find the best translation. We first search for an
 233      * exact match of the language, then a match of the language PRIMARYLANGID, then we
 234      * search for a LANG_NEUTRAL match, and if that still doesn't work we pick the
 235      * first entry which contains a proper productname. */
 236     locale = GetThreadLocale();
 237
 238     for (i = 0; i < translate_size / sizeof(LANGANDCODEPAGE); i++) {
 239         if (translate[i].wLanguage == locale &&
 240             query_productname(data, &translate[i], &productname, &productname_size)) {
 241             found = TRUE;
 242             break;
 243         }
 244     }
 245
 246     if (!found) {
 247         for (i = 0; i < translate_size / sizeof(LANGANDCODEPAGE); i++) {
 248             if (PRIMARYLANGID(translate[i].wLanguage) == PRIMARYLANGID(locale) &&
 249                 query_productname(data, &translate[i], &productname, &productname_size)) {
 250                 found = TRUE;
 251                 break;
 252             }
 253         }
 254     }
 255
 256     if (!found) {
 257         for (i = 0; i < translate_size / sizeof(LANGANDCODEPAGE); i++) {
 258             if (PRIMARYLANGID(translate[i].wLanguage) == LANG_NEUTRAL &&
 259                 query_productname(data, &translate[i], &productname, &productname_size)) {
 260                 found = TRUE;
 261                 break;
 262             }
 263         }
 264     }
 265
 266     if (!found) {
 267         for (i = 0; i < translate_size / sizeof(LANGANDCODEPAGE); i++) {
 268             if (query_productname(data, &translate[i], &productname, &productname_size)) {
 269                 found = TRUE;
 270                 break;
 271             }
 272         }
 273     }
 274 skip:
 275     if (found) {
 276         name = wcsdup(productname);
 277         free(data);
 278         return name;
 279     }
 280
 281     free(data);
 282
 283     name = wcsrchr(path, '\\');
 284     if (!name)
 285         name = path;
 286     else
 287         name++;
 288
 289     return wcsdup(name);
 290 }
 291
 292 static HRESULT WINAPI capture_QueryInterface(IAudioCaptureClient *iface, REFIID riid, void **ppv)
 293 {
 294     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 295
 296     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 297
 298     if (!ppv)
 299         return E_POINTER;
 300
 301     if (IsEqualIID(riid, &IID_IUnknown) ||
 302         IsEqualIID(riid, &IID_IAudioCaptureClient))
 303         *ppv = iface;
 304     else if (IsEqualIID(riid, &IID_IMarshal)) {
 305         return IUnknown_QueryInterface(This->marshal, riid, ppv);
 306     } else {
 307         *ppv = NULL;
 308         return E_NOINTERFACE;
 309     }
 310
 311     IUnknown_AddRef((IUnknown *)*ppv);
 312
 313     return S_OK;
 314 }
 315
 316 static ULONG WINAPI capture_AddRef(IAudioCaptureClient *iface)
 317 {
 318     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 319     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
 320 }
 321
 322 static ULONG WINAPI capture_Release(IAudioCaptureClient *iface)
 323 {
 324     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 325     return IAudioClient3_Release(&This->IAudioClient3_iface);
 326 }
 327
 328 static HRESULT WINAPI capture_GetBuffer(IAudioCaptureClient *iface, BYTE **data, UINT32 *frames,
 329                                         DWORD *flags, UINT64 *devpos, UINT64 *qpcpos)
 330 {
 331     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 332     struct get_capture_buffer_params params;
 333
 334     TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags, devpos, qpcpos);
 335
 336     if (!data)
 337         return E_POINTER;
 338
 339     *data = NULL;
 340
 341     if (!frames || !flags)
 342         return E_POINTER;
 343
 344     if (!This->stream)
 345         return AUDCLNT_E_NOT_INITIALIZED;
 346
 347     params.stream = This->stream;
 348     params.data   = data;
 349     params.frames = frames;
 350     params.flags  = (UINT *)flags;
 351     params.devpos = devpos;
 352     params.qpcpos = qpcpos;
 353
 354     wine_unix_call(get_capture_buffer, &params);
 355
 356     return params.result;
 357 }
 358
 359 static HRESULT WINAPI capture_ReleaseBuffer(IAudioCaptureClient *iface, UINT32 done)
 360 {
 361     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 362     struct release_capture_buffer_params params;
 363
 364     TRACE("(%p)->(%u)\n", This, done);
 365
 366     if (!This->stream)
 367         return AUDCLNT_E_NOT_INITIALIZED;
 368
 369     params.stream = This->stream;
 370     params.done   = done;
 371
 372     wine_unix_call(release_capture_buffer, &params);
 373
 374     return params.result;
 375 }
 376
 377 static HRESULT WINAPI capture_GetNextPacketSize(IAudioCaptureClient *iface, UINT32 *frames)
 378 {
 379     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 380     struct get_next_packet_size_params params;
 381
 382     TRACE("(%p)->(%p)\n", This, frames);
 383
 384     if (!frames)
 385         return E_POINTER;
 386
 387     if (!This->stream)
 388         return AUDCLNT_E_NOT_INITIALIZED;
 389
 390     params.stream = This->stream;
 391     params.frames = frames;
 392
 393     wine_unix_call(get_next_packet_size, &params);
 394
 395     return params.result;
 396 }
 397
 398 const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
 399 {
 400     capture_QueryInterface,
 401     capture_AddRef,
 402     capture_Release,
 403     capture_GetBuffer,
 404     capture_ReleaseBuffer,
 405     capture_GetNextPacketSize
 406 };
 407
 408 static HRESULT WINAPI client_QueryInterface(IAudioClient3 *iface, REFIID riid, void **ppv)
 409 {
 410     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 411
 412     if (!ppv)
 413         return E_POINTER;
 414
 415     if (IsEqualIID(riid, &IID_IUnknown) ||
 416         IsEqualIID(riid, &IID_IAudioClient) ||
 417         IsEqualIID(riid, &IID_IAudioClient2) ||
 418         IsEqualIID(riid, &IID_IAudioClient3))
 419         *ppv = iface;
 420     else if(IsEqualIID(riid, &IID_IMarshal)) {
 421         struct audio_client *This = impl_from_IAudioClient3(iface);
 422         return IUnknown_QueryInterface(This->marshal, riid, ppv);
 423     } else {
 424         *ppv = NULL;
 425         return E_NOINTERFACE;
 426     }
 427
 428     IUnknown_AddRef((IUnknown *)*ppv);
 429
 430     return S_OK;
 431 }
 432
 433 static ULONG WINAPI client_AddRef(IAudioClient3 *iface)
 434 {
 435     struct audio_client *This = impl_from_IAudioClient3(iface);
 436     ULONG ref = InterlockedIncrement(&This->ref);
 437     TRACE("(%p) Refcount now %lu\n", This, ref);
 438     return ref;
 439 }
 440
 441 static ULONG WINAPI client_Release(IAudioClient3 *iface)
 442 {
 443     struct audio_client *This = impl_from_IAudioClient3(iface);
 444     ULONG ref = InterlockedDecrement(&This->ref);
 445     TRACE("(%p) Refcount now %lu\n", This, ref);
 446
 447     if (!ref) {
 448         IAudioClient3_Stop(iface);
 449         IMMDevice_Release(This->parent);
 450         IUnknown_Release(This->marshal);
 451
 452         if (This->session) {
 453             sessions_lock();
 454             list_remove(&This->entry);
 455             sessions_unlock();
 456         }
 457
 458         free(This->vols);
 459
 460         if (This->stream)
 461             stream_release(This->stream, This->timer_thread);
 462
 463         free(This);
 464     }
 465
 466     return ref;
 467 }
 468
 469 static HRESULT WINAPI client_Initialize(IAudioClient3 *iface, AUDCLNT_SHAREMODE mode, DWORD flags,
 470                                  REFERENCE_TIME duration, REFERENCE_TIME period,
 471                                  const WAVEFORMATEX *fmt, const GUID *sessionguid)
 472 {
 473     struct audio_client *This = impl_from_IAudioClient3(iface);
 474     struct create_stream_params params;
 475     UINT32 i, channel_count;
 476     stream_handle stream;
 477     WCHAR *name;
 478
 479     TRACE("(%p)->(%x, %lx, %s, %s, %p, %s)\n", This, mode, flags, wine_dbgstr_longlong(duration),
 480                                                wine_dbgstr_longlong(period), fmt,
 481                                                debugstr_guid(sessionguid));
 482
 483     if (!fmt)
 484         return E_POINTER;
 485
 486     dump_fmt(fmt);
 487
 488     if (mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
 489         return E_INVALIDARG;
 490
 491     if (flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
 492                   AUDCLNT_STREAMFLAGS_LOOPBACK |
 493                   AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
 494                   AUDCLNT_STREAMFLAGS_NOPERSIST |
 495                   AUDCLNT_STREAMFLAGS_RATEADJUST |
 496                   AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
 497                   AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
 498                   AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED |
 499                   AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY |
 500                   AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM)) {
 501         FIXME("Unknown flags: %08lx\n", flags);
 502         return E_INVALIDARG;
 503     }
 504
 505     sessions_lock();
 506
 507     if (This->stream) {
 508         sessions_unlock();
 509         return AUDCLNT_E_ALREADY_INITIALIZED;
 510     }
 511
 512     if (FAILED(params.result = main_loop_start())) {
 513         sessions_unlock();
 514         return params.result;
 515     }
 516
 517     params.name = name   = get_application_name();
 518     params.device        = This->device_name;
 519     params.flow          = This->dataflow;
 520     params.share         = mode;
 521     params.flags         = flags;
 522     params.duration      = duration;
 523     params.period        = period;
 524     params.fmt           = fmt;
 525     params.channel_count = &channel_count;
 526     params.stream        = &stream;
 527
 528     wine_unix_call(create_stream, &params);
 529
 530     free(name);
 531
 532     if (FAILED(params.result)) {
 533         sessions_unlock();
 534         return params.result;
 535     }
 536
 537     if (!(This->vols = malloc(channel_count * sizeof(*This->vols)))) {
 538         params.result = E_OUTOFMEMORY;
 539         goto exit;
 540     }
 541
 542     for (i = 0; i < channel_count; i++)
 543         This->vols[i] = 1.f;
 544
 545     params.result = get_audio_session(sessionguid, This->parent, channel_count, &This->session);
 546
 547 exit:
 548     if (FAILED(params.result)) {
 549         stream_release(stream, NULL);
 550         free(This->vols);
 551         This->vols = NULL;
 552     } else {
 553         list_add_tail(&This->session->clients, &This->entry);
 554         This->stream = stream;
 555         This->channel_count = channel_count;
 556         set_stream_volumes(This);
 557     }
 558
 559     sessions_unlock();
 560
 561     return params.result;
 562 }
 563
 564 static HRESULT WINAPI client_GetBufferSize(IAudioClient3 *iface, UINT32 *out)
 565 {
 566     struct audio_client *This = impl_from_IAudioClient3(iface);
 567     struct get_buffer_size_params params;
 568
 569     TRACE("(%p)->(%p)\n", This, out);
 570
 571     if (!out)
 572         return E_POINTER;
 573
 574     if (!This->stream)
 575         return AUDCLNT_E_NOT_INITIALIZED;
 576
 577     params.stream = This->stream;
 578     params.frames = out;
 579
 580     wine_unix_call(get_buffer_size, &params);
 581
 582     return params.result;
 583 }
 584
 585 static HRESULT WINAPI client_GetStreamLatency(IAudioClient3 *iface, REFERENCE_TIME *latency)
 586 {
 587     struct audio_client *This = impl_from_IAudioClient3(iface);
 588     struct get_latency_params params;
 589
 590     TRACE("(%p)->(%p)\n", This, latency);
 591
 592     if (!latency)
 593         return E_POINTER;
 594
 595     if (!This->stream)
 596         return AUDCLNT_E_NOT_INITIALIZED;
 597
 598     params.stream  = This->stream;
 599     params.latency = latency;
 600
 601     wine_unix_call(get_latency, &params);
 602
 603     return params.result;
 604 }
 605
 606 static HRESULT WINAPI client_GetCurrentPadding(IAudioClient3 *iface, UINT32 *out)
 607 {
 608     struct audio_client *This = impl_from_IAudioClient3(iface);
 609     struct get_current_padding_params params;
 610
 611     TRACE("(%p)->(%p)\n", This, out);
 612
 613     if (!out)
 614         return E_POINTER;
 615
 616     if (!This->stream)
 617         return AUDCLNT_E_NOT_INITIALIZED;
 618
 619     params.stream  = This->stream;
 620     params.padding = out;
 621
 622     wine_unix_call(get_current_padding, &params);
 623
 624     return params.result;
 625 }
 626
 627 static HRESULT WINAPI client_IsFormatSupported(IAudioClient3 *iface, AUDCLNT_SHAREMODE mode,
 628                                         const WAVEFORMATEX *fmt, WAVEFORMATEX **out)
 629 {
 630     struct audio_client *This = impl_from_IAudioClient3(iface);
 631     struct is_format_supported_params params;
 632
 633     TRACE("(%p)->(%x, %p, %p)\n", This, mode, fmt, out);
 634
 635     if (fmt)
 636         dump_fmt(fmt);
 637
 638     params.device  = This->device_name;
 639     params.flow    = This->dataflow;
 640     params.share   = mode;
 641     params.fmt_in  = fmt;
 642     params.fmt_out = NULL;
 643
 644     if (out) {
 645         *out = NULL;
 646         if (mode == AUDCLNT_SHAREMODE_SHARED)
 647             params.fmt_out = CoTaskMemAlloc(sizeof(*params.fmt_out));
 648     }
 649
 650     wine_unix_call(is_format_supported, &params);
 651
 652     if (params.result == S_FALSE)
 653         *out = &params.fmt_out->Format;
 654     else
 655         CoTaskMemFree(params.fmt_out);
 656
 657     return params.result;
 658 }
 659
 660 static HRESULT WINAPI client_GetMixFormat(IAudioClient3 *iface, WAVEFORMATEX **pwfx)
 661 {
 662     struct audio_client *This = impl_from_IAudioClient3(iface);
 663     struct get_mix_format_params params;
 664
 665     TRACE("(%p)->(%p)\n", This, pwfx);
 666
 667     if (!pwfx)
 668         return E_POINTER;
 669
 670     *pwfx = NULL;
 671
 672     params.device = This->device_name;
 673     params.flow   = This->dataflow;
 674     params.fmt    = CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE));
 675     if (!params.fmt)
 676         return E_OUTOFMEMORY;
 677
 678     wine_unix_call(get_mix_format, &params);
 679
 680     if (SUCCEEDED(params.result)) {
 681         *pwfx = &params.fmt->Format;
 682         dump_fmt(*pwfx);
 683     } else
 684         CoTaskMemFree(params.fmt);
 685
 686     return params.result;
 687 }
 688
 689 static HRESULT WINAPI client_GetDevicePeriod(IAudioClient3 *iface, REFERENCE_TIME *defperiod,
 690                                       REFERENCE_TIME *minperiod)
 691 {
 692     struct audio_client *This = impl_from_IAudioClient3(iface);
 693     struct get_device_period_params params;
 694
 695     TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
 696
 697     if (!defperiod && !minperiod)
 698         return E_POINTER;
 699
 700     params.device     = This->device_name;
 701     params.flow       = This->dataflow;
 702     params.def_period = defperiod;
 703     params.min_period = minperiod;
 704
 705     wine_unix_call(get_device_period, &params);
 706
 707     return params.result;
 708 }
 709
 710 static HRESULT WINAPI client_Start(IAudioClient3 *iface)
 711 {
 712     struct audio_client *This = impl_from_IAudioClient3(iface);
 713     struct start_params params;
 714
 715     TRACE("(%p)\n", This);
 716
 717     sessions_lock();
 718
 719     if (!This->stream) {
 720         sessions_unlock();
 721         return AUDCLNT_E_NOT_INITIALIZED;
 722     }
 723
 724     params.stream = This->stream;
 725     wine_unix_call(start, &params);
 726
 727     if (SUCCEEDED(params.result) && !This->timer_thread) {
 728         if ((This->timer_thread = CreateThread(NULL, 0, timer_loop_func, This, 0, NULL)))
 729             SetThreadPriority(This->timer_thread, THREAD_PRIORITY_TIME_CRITICAL);
 730         else {
 731             IAudioClient3_Stop(&This->IAudioClient3_iface);
 732             params.result = E_FAIL;
 733         }
 734     }
 735
 736     sessions_unlock();
 737
 738     return params.result;
 739 }
 740
 741 static HRESULT WINAPI client_Stop(IAudioClient3 *iface)
 742 {
 743     struct audio_client *This = impl_from_IAudioClient3(iface);
 744     struct stop_params params;
 745
 746     TRACE("(%p)\n", This);
 747
 748     if (!This->stream)
 749         return AUDCLNT_E_NOT_INITIALIZED;
 750
 751     params.stream = This->stream;
 752
 753     wine_unix_call(stop, &params);
 754
 755     return params.result;
 756 }
 757
 758 static HRESULT WINAPI client_Reset(IAudioClient3 *iface)
 759 {
 760     struct audio_client *This = impl_from_IAudioClient3(iface);
 761     struct reset_params params;
 762
 763     TRACE("(%p)\n", This);
 764
 765     if (!This->stream)
 766         return AUDCLNT_E_NOT_INITIALIZED;
 767
 768     params.stream = This->stream;
 769
 770     wine_unix_call(reset, &params);
 771
 772     return params.result;
 773 }
 774
 775 static HRESULT WINAPI client_SetEventHandle(IAudioClient3 *iface, HANDLE event)
 776 {
 777     struct audio_client *This = impl_from_IAudioClient3(iface);
 778     struct set_event_handle_params params;
 779
 780     TRACE("(%p)->(%p)\n", This, event);
 781
 782     if (!event)
 783         return E_INVALIDARG;
 784
 785     if (!This->stream)
 786         return AUDCLNT_E_NOT_INITIALIZED;
 787
 788     params.stream = This->stream;
 789     params.event  = event;
 790
 791     wine_unix_call(set_event_handle, &params);
 792
 793     return params.result;
 794 }
 795
 796 static HRESULT WINAPI client_GetService(IAudioClient3 *iface, REFIID riid, void **ppv)
 797 {
 798     struct audio_client *This = impl_from_IAudioClient3(iface);
 799     HRESULT hr;
 800
 801     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 802
 803     if (!ppv)
 804         return E_POINTER;
 805
 806     *ppv = NULL;
 807
 808     sessions_lock();
 809
 810     if (!This->stream) {
 811         hr = AUDCLNT_E_NOT_INITIALIZED;
 812         goto exit;
 813     }
 814
 815     if (IsEqualIID(riid, &IID_IAudioRenderClient)) {
 816         if (This->dataflow != eRender) {
 817             hr = AUDCLNT_E_WRONG_ENDPOINT_TYPE;
 818             goto exit;
 819         }
 820
 821         IAudioRenderClient_AddRef(&This->IAudioRenderClient_iface);
 822         *ppv = &This->IAudioRenderClient_iface;
 823     } else if (IsEqualIID(riid, &IID_IAudioCaptureClient)) {
 824         if (This->dataflow != eCapture) {
 825             hr = AUDCLNT_E_WRONG_ENDPOINT_TYPE;
 826             goto exit;
 827         }
 828
 829         IAudioCaptureClient_AddRef(&This->IAudioCaptureClient_iface);
 830         *ppv = &This->IAudioCaptureClient_iface;
 831     } else if (IsEqualIID(riid, &IID_IAudioClock)) {
 832         IAudioClock_AddRef(&This->IAudioClock_iface);
 833         *ppv = &This->IAudioClock_iface;
 834     } else if (IsEqualIID(riid, &IID_IAudioStreamVolume)) {
 835         IAudioStreamVolume_AddRef(&This->IAudioStreamVolume_iface);
 836         *ppv = &This->IAudioStreamVolume_iface;
 837     } else if (IsEqualIID(riid, &IID_IAudioSessionControl) ||
 838                IsEqualIID(riid, &IID_IChannelAudioVolume) ||
 839                IsEqualIID(riid, &IID_ISimpleAudioVolume)) {
 840         const BOOLEAN new_session = !This->session_wrapper;
 841         if (new_session) {
 842             This->session_wrapper = session_wrapper_create(This);
 843             if (!This->session_wrapper) {
 844                 hr = E_OUTOFMEMORY;
 845                 goto exit;
 846             }
 847         }
 848
 849         if (IsEqualIID(riid, &IID_IAudioSessionControl))
 850             *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
 851         else if (IsEqualIID(riid, &IID_IChannelAudioVolume))
 852             *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
 853         else if (IsEqualIID(riid, &IID_ISimpleAudioVolume))
 854             *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
 855
 856         if (!new_session)
 857             IUnknown_AddRef((IUnknown *)*ppv);
 858     } else {
 859             FIXME("stub %s\n", debugstr_guid(riid));
 860             hr = E_NOINTERFACE;
 861             goto exit;
 862     }
 863
 864     hr = S_OK;
 865 exit:
 866     sessions_unlock();
 867
 868     return hr;
 869 }
 870
 871 static HRESULT WINAPI client_IsOffloadCapable(IAudioClient3 *iface, AUDIO_STREAM_CATEGORY category,
 872                                        BOOL *offload_capable)
 873 {
 874     struct audio_client *This = impl_from_IAudioClient3(iface);
 875
 876     TRACE("(%p)->(0x%x, %p)\n", This, category, offload_capable);
 877
 878     if (!offload_capable)
 879         return E_INVALIDARG;
 880
 881     *offload_capable = FALSE;
 882
 883     return S_OK;
 884 }
 885
 886 static HRESULT WINAPI client_SetClientProperties(IAudioClient3 *iface,
 887                                           const AudioClientProperties *prop)
 888 {
 889     struct audio_client *This = impl_from_IAudioClient3(iface);
 890     const Win8AudioClientProperties *legacy_prop = (const Win8AudioClientProperties *)prop;
 891
 892     TRACE("(%p)->(%p)\n", This, prop);
 893
 894     if (!legacy_prop)
 895         return E_POINTER;
 896
 897     if (legacy_prop->cbSize == sizeof(AudioClientProperties)) {
 898         TRACE("{ bIsOffload: %u, eCategory: 0x%x, Options: 0x%x }\n", legacy_prop->bIsOffload,
 899                                                                       legacy_prop->eCategory,
 900                                                                       prop->Options);
 901     } else if(legacy_prop->cbSize == sizeof(Win8AudioClientProperties)) {
 902         TRACE("{ bIsOffload: %u, eCategory: 0x%x }\n", legacy_prop->bIsOffload,
 903                                                        legacy_prop->eCategory);
 904     } else {
 905         WARN("Unsupported Size = %d\n", legacy_prop->cbSize);
 906         return E_INVALIDARG;
 907     }
 908
 909     if (legacy_prop->bIsOffload)
 910         return AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE;
 911
 912     return S_OK;
 913 }
 914
 915 static HRESULT WINAPI client_GetBufferSizeLimits(IAudioClient3 *iface, const WAVEFORMATEX *format,
 916                                           BOOL event_driven, REFERENCE_TIME *min_duration,
 917                                           REFERENCE_TIME *max_duration)
 918 {
 919     struct audio_client *This = impl_from_IAudioClient3(iface);
 920     FIXME("(%p)->(%p, %u, %p, %p) - stub\n", This, format, event_driven, min_duration, max_duration);
 921     return E_NOTIMPL;
 922 }
 923
 924 static HRESULT WINAPI client_GetSharedModeEnginePeriod(IAudioClient3 *iface,
 925                                                 const WAVEFORMATEX *format,
 926                                                 UINT32 *default_period_frames,
 927                                                 UINT32 *unit_period_frames,
 928                                                 UINT32 *min_period_frames,
 929                                                 UINT32 *max_period_frames)
 930 {
 931     struct audio_client *This = impl_from_IAudioClient3(iface);
 932     FIXME("(%p)->(%p, %p, %p, %p, %p) - stub\n", This, format, default_period_frames,
 933                                                  unit_period_frames, min_period_frames,
 934                                                  max_period_frames);
 935     return E_NOTIMPL;
 936 }
 937
 938 static HRESULT WINAPI client_GetCurrentSharedModeEnginePeriod(IAudioClient3 *iface,
 939                                                        WAVEFORMATEX **cur_format,
 940                                                        UINT32 *cur_period_frames)
 941 {
 942     struct audio_client *This = impl_from_IAudioClient3(iface);
 943     FIXME("(%p)->(%p, %p) - stub\n", This, cur_format, cur_period_frames);
 944     return E_NOTIMPL;
 945 }
 946
 947 static HRESULT WINAPI client_InitializeSharedAudioStream(IAudioClient3 *iface, DWORD flags,
 948                                                   UINT32 period_frames,
 949                                                   const WAVEFORMATEX *format,
 950                                                   const GUID *session_guid)
 951 {
 952     struct audio_client *This = impl_from_IAudioClient3(iface);
 953     FIXME("(%p)->(0x%lx, %u, %p, %s) - stub\n", This, flags, period_frames, format, debugstr_guid(session_guid));
 954     return E_NOTIMPL;
 955 }
 956
 957 const IAudioClient3Vtbl AudioClient3_Vtbl =
 958 {
 959     client_QueryInterface,
 960     client_AddRef,
 961     client_Release,
 962     client_Initialize,
 963     client_GetBufferSize,
 964     client_GetStreamLatency,
 965     client_GetCurrentPadding,
 966     client_IsFormatSupported,
 967     client_GetMixFormat,
 968     client_GetDevicePeriod,
 969     client_Start,
 970     client_Stop,
 971     client_Reset,
 972     client_SetEventHandle,
 973     client_GetService,
 974     client_IsOffloadCapable,
 975     client_SetClientProperties,
 976     client_GetBufferSizeLimits,
 977     client_GetSharedModeEnginePeriod,
 978     client_GetCurrentSharedModeEnginePeriod,
 979     client_InitializeSharedAudioStream,
 980 };
 981
 982 static HRESULT WINAPI clock_QueryInterface(IAudioClock *iface, REFIID riid, void **ppv)
 983 {
 984     struct audio_client *This = impl_from_IAudioClock(iface);
 985
 986     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 987
 988     if (!ppv)
 989         return E_POINTER;
 990
 991     if (IsEqualIID(riid, &IID_IUnknown) ||
 992         IsEqualIID(riid, &IID_IAudioClock))
 993         *ppv = iface;
 994     else if (IsEqualIID(riid, &IID_IAudioClock2))
 995         *ppv = &This->IAudioClock2_iface;
 996     else if (IsEqualIID(riid, &IID_IMarshal)) {
 997         return IUnknown_QueryInterface(This->marshal, riid, ppv);
 998     } else {
 999         *ppv = NULL;
1000         return E_NOINTERFACE;
1001     }
1002
1003     IUnknown_AddRef((IUnknown *)*ppv);
1004
1005     return S_OK;
1006 }
1007
1008 static ULONG WINAPI clock_AddRef(IAudioClock *iface)
1009 {
1010     struct audio_client *This = impl_from_IAudioClock(iface);
1011     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1012 }
1013
1014 static ULONG WINAPI clock_Release(IAudioClock *iface)
1015 {
1016     struct audio_client *This = impl_from_IAudioClock(iface);
1017     return IAudioClient3_Release(&This->IAudioClient3_iface);
1018 }
1019
1020 static HRESULT WINAPI clock_GetFrequency(IAudioClock *iface, UINT64 *freq)
1021 {
1022     struct audio_client *This = impl_from_IAudioClock(iface);
1023     struct get_frequency_params params;
1024
1025     TRACE("(%p)->(%p)\n", This, freq);
1026
1027     if (!This->stream)
1028         return AUDCLNT_E_NOT_INITIALIZED;
1029
1030     params.stream = This->stream;
1031     params.freq   = freq;
1032
1033     wine_unix_call(get_frequency, &params);
1034
1035     return params.result;
1036 }
1037
1038 static HRESULT WINAPI clock_GetPosition(IAudioClock *iface, UINT64 *pos, UINT64 *qpctime)
1039 {
1040     struct audio_client *This = impl_from_IAudioClock(iface);
1041     struct get_position_params params;
1042
1043     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
1044
1045     if (!pos)
1046         return E_POINTER;
1047
1048     if (!This->stream)
1049         return AUDCLNT_E_NOT_INITIALIZED;
1050
1051     params.stream  = This->stream;
1052     params.device  = FALSE;
1053     params.pos     = pos;
1054     params.qpctime = qpctime;
1055
1056     wine_unix_call(get_position, &params);
1057
1058     return params.result;
1059 }
1060
1061 static HRESULT WINAPI clock_GetCharacteristics(IAudioClock *iface, DWORD *chars)
1062 {
1063     struct audio_client *This = impl_from_IAudioClock(iface);
1064
1065     TRACE("(%p)->(%p)\n", This, chars);
1066
1067     if (!chars)
1068         return E_POINTER;
1069
1070     *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
1071
1072     return S_OK;
1073 }
1074
1075 const IAudioClockVtbl AudioClock_Vtbl =
1076 {
1077     clock_QueryInterface,
1078     clock_AddRef,
1079     clock_Release,
1080     clock_GetFrequency,
1081     clock_GetPosition,
1082     clock_GetCharacteristics
1083 };
1084
1085 static HRESULT WINAPI clock2_QueryInterface(IAudioClock2 *iface, REFIID riid, void **ppv)
1086 {
1087     struct audio_client *This = impl_from_IAudioClock2(iface);
1088     return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
1089 }
1090
1091 static ULONG WINAPI clock2_AddRef(IAudioClock2 *iface)
1092 {
1093     struct audio_client *This = impl_from_IAudioClock2(iface);
1094     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1095 }
1096
1097 static ULONG WINAPI clock2_Release(IAudioClock2 *iface)
1098 {
1099     struct audio_client *This = impl_from_IAudioClock2(iface);
1100     return IAudioClient3_Release(&This->IAudioClient3_iface);
1101 }
1102
1103 static HRESULT WINAPI clock2_GetDevicePosition(IAudioClock2 *iface, UINT64 *pos, UINT64 *qpctime)
1104 {
1105     struct audio_client *This = impl_from_IAudioClock2(iface);
1106     struct get_position_params params;
1107
1108     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
1109
1110     if (!pos)
1111         return E_POINTER;
1112
1113     if (!This->stream)
1114         return AUDCLNT_E_NOT_INITIALIZED;
1115
1116     params.stream  = This->stream;
1117     params.device  = TRUE;
1118     params.pos     = pos;
1119     params.qpctime = qpctime;
1120
1121     wine_unix_call(get_position, &params);
1122
1123     return params.result;
1124 }
1125
1126 const IAudioClock2Vtbl AudioClock2_Vtbl =
1127 {
1128     clock2_QueryInterface,
1129     clock2_AddRef,
1130     clock2_Release,
1131     clock2_GetDevicePosition
1132 };
1133
1134 static HRESULT WINAPI render_QueryInterface(IAudioRenderClient *iface, REFIID riid, void **ppv)
1135 {
1136     struct audio_client *This = impl_from_IAudioRenderClient(iface);
1137
1138     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1139
1140     if (!ppv)
1141         return E_POINTER;
1142
1143     if (IsEqualIID(riid, &IID_IUnknown) ||
1144         IsEqualIID(riid, &IID_IAudioRenderClient))
1145         *ppv = iface;
1146     else if (IsEqualIID(riid, &IID_IMarshal)) {
1147         return IUnknown_QueryInterface(This->marshal, riid, ppv);
1148     } else {
1149         *ppv = NULL;
1150         return E_NOINTERFACE;
1151     }
1152
1153     IUnknown_AddRef((IUnknown *)*ppv);
1154
1155     return S_OK;
1156 }
1157
1158 static ULONG WINAPI render_AddRef(IAudioRenderClient *iface)
1159 {
1160     struct audio_client *This = impl_from_IAudioRenderClient(iface);
1161     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1162 }
1163
1164 static ULONG WINAPI render_Release(IAudioRenderClient *iface)
1165 {
1166     struct audio_client *This = impl_from_IAudioRenderClient(iface);
1167     return IAudioClient3_Release(&This->IAudioClient3_iface);
1168 }
1169
1170 static HRESULT WINAPI render_GetBuffer(IAudioRenderClient *iface, UINT32 frames, BYTE **data)
1171 {
1172     struct audio_client *This = impl_from_IAudioRenderClient(iface);
1173     struct get_render_buffer_params params;
1174
1175     TRACE("(%p)->(%u, %p)\n", This, frames, data);
1176
1177     if (!data)
1178         return E_POINTER;
1179
1180     if (!This->stream)
1181         return AUDCLNT_E_NOT_INITIALIZED;
1182
1183     *data = NULL;
1184
1185     params.stream = This->stream;
1186     params.frames = frames;
1187     params.data   = data;
1188
1189     wine_unix_call(get_render_buffer, &params);
1190
1191     return params.result;
1192 }
1193
1194 static HRESULT WINAPI render_ReleaseBuffer(IAudioRenderClient *iface, UINT32 written_frames,
1195                                            DWORD flags)
1196 {
1197     struct audio_client *This = impl_from_IAudioRenderClient(iface);
1198     struct release_render_buffer_params params;
1199
1200     TRACE("(%p)->(%u, %lx)\n", This, written_frames, flags);
1201
1202     if (!This->stream)
1203         return AUDCLNT_E_NOT_INITIALIZED;
1204
1205     params.stream         = This->stream;
1206     params.written_frames = written_frames;
1207     params.flags          = flags;
1208
1209     wine_unix_call(release_render_buffer, &params);
1210
1211     return params.result;
1212 }
1213
1214 const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
1215     render_QueryInterface,
1216     render_AddRef,
1217     render_Release,
1218     render_GetBuffer,
1219     render_ReleaseBuffer
1220 };
1221
1222 static HRESULT WINAPI streamvolume_QueryInterface(IAudioStreamVolume *iface, REFIID riid,
1223                                                   void **ppv)
1224 {
1225     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1226
1227     if (!ppv)
1228         return E_POINTER;
1229
1230     if (IsEqualIID(riid, &IID_IUnknown) ||
1231         IsEqualIID(riid, &IID_IAudioStreamVolume))
1232         *ppv = iface;
1233     else if (IsEqualIID(riid, &IID_IMarshal)) {
1234         struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1235         return IUnknown_QueryInterface(This->marshal, riid, ppv);
1236     } else {
1237         *ppv = NULL;
1238         return E_NOINTERFACE;
1239     }
1240
1241     IUnknown_AddRef((IUnknown *)*ppv);
1242
1243     return S_OK;
1244 }
1245
1246 static ULONG WINAPI streamvolume_AddRef(IAudioStreamVolume *iface)
1247 {
1248     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1249     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
1250 }
1251
1252 static ULONG WINAPI streamvolume_Release(IAudioStreamVolume *iface)
1253 {
1254     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1255     return IAudioClient3_Release(&This->IAudioClient3_iface);
1256 }
1257
1258 static HRESULT WINAPI streamvolume_GetChannelCount(IAudioStreamVolume *iface, UINT32 *out)
1259 {
1260     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1261
1262     TRACE("(%p)->(%p)\n", This, out);
1263
1264     if (!out)
1265         return E_POINTER;
1266
1267     *out = This->channel_count;
1268
1269     return S_OK;
1270 }
1271
1272 static HRESULT WINAPI streamvolume_SetChannelVolume(IAudioStreamVolume *iface, UINT32 index,
1273                                                     float level)
1274 {
1275     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1276
1277     TRACE("(%p)->(%d, %f)\n", This, index, level);
1278
1279     if (level < 0.f || level > 1.f)
1280         return E_INVALIDARG;
1281
1282     if (!This->stream)
1283         return AUDCLNT_E_NOT_INITIALIZED;
1284
1285     if (index >= This->channel_count)
1286         return E_INVALIDARG;
1287
1288     sessions_lock();
1289
1290     This->vols[index] = level;
1291     set_stream_volumes(This);
1292
1293     sessions_unlock();
1294
1295     return S_OK;
1296 }
1297
1298 static HRESULT WINAPI streamvolume_GetChannelVolume(IAudioStreamVolume *iface, UINT32 index,
1299                                                     float *level)
1300 {
1301     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1302
1303     TRACE("(%p)->(%d, %p)\n", This, index, level);
1304
1305     if (!level)
1306         return E_POINTER;
1307
1308     if (!This->stream)
1309         return AUDCLNT_E_NOT_INITIALIZED;
1310
1311     if (index >= This->channel_count)
1312         return E_INVALIDARG;
1313
1314     *level = This->vols[index];
1315
1316     return S_OK;
1317 }
1318
1319 static HRESULT WINAPI streamvolume_SetAllVolumes(IAudioStreamVolume *iface, UINT32 count,
1320                                                  const float *levels)
1321 {
1322     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1323     unsigned int i;
1324
1325     TRACE("(%p)->(%d, %p)\n", This, count, levels);
1326
1327     if (!levels)
1328         return E_POINTER;
1329
1330     if (!This->stream)
1331         return AUDCLNT_E_NOT_INITIALIZED;
1332
1333     if (count != This->channel_count)
1334         return E_INVALIDARG;
1335
1336     sessions_lock();
1337
1338     for (i = 0; i < count; ++i)
1339         This->vols[i] = levels[i];
1340     set_stream_volumes(This);
1341
1342     sessions_unlock();
1343
1344     return S_OK;
1345 }
1346
1347 static HRESULT WINAPI streamvolume_GetAllVolumes(IAudioStreamVolume *iface, UINT32 count,
1348                                                  float *levels)
1349 {
1350     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
1351     unsigned int i;
1352
1353     TRACE("(%p)->(%d, %p)\n", This, count, levels);
1354
1355     if (!levels)
1356         return E_POINTER;
1357
1358     if (!This->stream)
1359         return AUDCLNT_E_NOT_INITIALIZED;
1360
1361     if (count != This->channel_count)
1362         return E_INVALIDARG;
1363
1364     sessions_lock();
1365
1366     for (i = 0; i < count; ++i)
1367         levels[i] = This->vols[i];
1368
1369     sessions_unlock();
1370
1371     return S_OK;
1372 }
1373
1374 const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
1375 {
1376     streamvolume_QueryInterface,
1377     streamvolume_AddRef,
1378     streamvolume_Release,
1379     streamvolume_GetChannelCount,
1380     streamvolume_SetChannelVolume,
1381     streamvolume_GetChannelVolume,
1382     streamvolume_SetAllVolumes,
1383     streamvolume_GetAllVolumes
1384 };
1385
1386 HRESULT AudioClient_Create(GUID *guid, IMMDevice *device, IAudioClient **out)
1387 {
1388     struct audio_client *This;
1389     char *name;
1390     EDataFlow dataflow;
1391     size_t size;
1392     HRESULT hr;
1393
1394     TRACE("%s %p %p\n", debugstr_guid(guid), device, out);
1395
1396     *out = NULL;
1397
1398     if (!drvs.pget_device_name_from_guid(guid, &name, &dataflow))
1399         return AUDCLNT_E_DEVICE_INVALIDATED;
1400
1401     if (dataflow != eRender && dataflow != eCapture) {
1402         free(name);
1403         return E_UNEXPECTED;
1404     }
1405
1406     size = strlen(name) + 1;
1407     This = calloc(1, FIELD_OFFSET(struct audio_client, device_name[size]));
1408     if (!This) {
1409         free(name);
1410         return E_OUTOFMEMORY;
1411     }
1412
1413     memcpy(This->device_name, name, size);
1414     free(name);
1415
1416     This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
1417     This->IAudioClient3_iface.lpVtbl       = &AudioClient3_Vtbl;
1418     This->IAudioClock_iface.lpVtbl         = &AudioClock_Vtbl;
1419     This->IAudioClock2_iface.lpVtbl        = &AudioClock2_Vtbl;
1420     This->IAudioRenderClient_iface.lpVtbl  = &AudioRenderClient_Vtbl;
1421     This->IAudioStreamVolume_iface.lpVtbl  = &AudioStreamVolume_Vtbl;
1422
1423     This->dataflow = dataflow;
1424     This->parent   = device;
1425
1426     hr = CoCreateFreeThreadedMarshaler((IUnknown *)&This->IAudioClient3_iface, &This->marshal);
1427     if (FAILED(hr)) {
1428         free(This);
1429         return hr;
1430     }
1431
1432     IMMDevice_AddRef(This->parent);
1433
1434     *out = (IAudioClient *)&This->IAudioClient3_iface;
1435     IAudioClient3_AddRef(&This->IAudioClient3_iface);
1436
1437     return S_OK;
1438 }