Alc/backends/mmdevapi.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2011 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 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  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #define COBJMACROS
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <memory.h>
  27
  28 #include <mmdeviceapi.h>
  29 #include <audioclient.h>
  30 #include <cguid.h>
  31 #include <devpropdef.h>
  32 #include <mmreg.h>
  33 #include <propsys.h>
  34 #include <propkey.h>
  35 #include <devpkey.h>
  36 #ifndef _WAVEFORMATEXTENSIBLE_
  37 #include <ks.h>
  38 #include <ksmedia.h>
  39 #endif
  40
  41 #include "alMain.h"
  42 #include "alu.h"
  43 #include "threads.h"
  44 #include "compat.h"
  45 #include "alstring.h"
  46
  47 #include "backends/base.h"
  48
  49
  50 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  51 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  52
  53 DEFINE_DEVPROPKEY(DEVPKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80,0x20, 0x67,0xd1,0x46,0xa8,0x50,0xe0, 14);
  54 DEFINE_PROPERTYKEY(PKEY_AudioEndpoint_FormFactor, 0x1da5d803, 0xd492, 0x4edd, 0x8c,0x23, 0xe0,0xc0,0xff,0xee,0x7f,0x0e, 0);
  55
  56 #define MONO SPEAKER_FRONT_CENTER
  57 #define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
  58 #define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  59 #define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  60 #define X5DOT1REAR (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  61 #define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  62 #define X7DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  63 #define X7DOT1_WIDE (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_FRONT_LEFT_OF_CENTER|SPEAKER_FRONT_RIGHT_OF_CENTER)
  64
  65 #define DEVNAME_HEAD "OpenAL Soft on "
  66
  67
  68 typedef struct {
  69     al_string name;
  70     WCHAR *devid;
  71 } DevMap;
  72 TYPEDEF_VECTOR(DevMap, vector_DevMap)
  73
  74 static void clear_devlist(vector_DevMap *list)
  75 {
  76 #define CLEAR_DEVMAP(i) do {     \
  77     AL_STRING_DEINIT((i)->name); \
  78     free((i)->devid);            \
  79     (i)->devid = NULL;           \
  80 } while(0)
  81     VECTOR_FOR_EACH(DevMap, *list, CLEAR_DEVMAP);
  82     VECTOR_RESIZE(*list, 0, 0);
  83 #undef CLEAR_DEVMAP
  84 }
  85
  86 static vector_DevMap PlaybackDevices;
  87 static vector_DevMap CaptureDevices;
  88
  89
  90 static HANDLE ThreadHdl;
  91 static DWORD ThreadID;
  92
  93 typedef struct {
  94     HANDLE FinishedEvt;
  95     HRESULT result;
  96 } ThreadRequest;
  97
  98 #define WM_USER_First       (WM_USER+0)
  99 #define WM_USER_OpenDevice  (WM_USER+0)
 100 #define WM_USER_ResetDevice (WM_USER+1)
 101 #define WM_USER_StartDevice (WM_USER+2)
 102 #define WM_USER_StopDevice  (WM_USER+3)
 103 #define WM_USER_CloseDevice (WM_USER+4)
 104 #define WM_USER_Enumerate   (WM_USER+5)
 105 #define WM_USER_Last        (WM_USER+5)
 106
 107 static inline void ReturnMsgResponse(ThreadRequest *req, HRESULT res)
 108 {
 109     req->result = res;
 110     SetEvent(req->FinishedEvt);
 111 }
 112
 113 static HRESULT WaitForResponse(ThreadRequest *req)
 114 {
 115     if(WaitForSingleObject(req->FinishedEvt, INFINITE) == WAIT_OBJECT_0)
 116         return req->result;
 117     ERR("Message response error: %lu\n", GetLastError());
 118     return E_FAIL;
 119 }
 120
 121
 122 static void get_device_name(IMMDevice *device, al_string *name)
 123 {
 124     IPropertyStore *ps;
 125     PROPVARIANT pvname;
 126     HRESULT hr;
 127
 128     al_string_copy_cstr(name, DEVNAME_HEAD);
 129
 130     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 131     if(FAILED(hr))
 132     {
 133         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 134         al_string_append_cstr(name, "Unknown Device Name");
 135         return;
 136     }
 137
 138     PropVariantInit(&pvname);
 139
 140     hr = IPropertyStore_GetValue(ps, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pvname);
 141     if(FAILED(hr))
 142     {
 143         WARN("GetValue Device_FriendlyName failed: 0x%08lx\n", hr);
 144         al_string_append_cstr(name, "Unknown Device Name");
 145     }
 146     else if(pvname.vt == VT_LPWSTR)
 147         al_string_append_wcstr(name, pvname.pwszVal);
 148     else
 149     {
 150         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvname.vt);
 151         al_string_append_cstr(name, "Unknown Device Name");
 152     }
 153
 154     PropVariantClear(&pvname);
 155     IPropertyStore_Release(ps);
 156 }
 157
 158 static void get_device_formfactor(IMMDevice *device, EndpointFormFactor *formfactor)
 159 {
 160     IPropertyStore *ps;
 161     PROPVARIANT pvform;
 162     HRESULT hr;
 163
 164     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 165     if(FAILED(hr))
 166     {
 167         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 168         return;
 169     }
 170
 171     PropVariantInit(&pvform);
 172
 173     hr = IPropertyStore_GetValue(ps, &PKEY_AudioEndpoint_FormFactor, &pvform);
 174     if(FAILED(hr))
 175         WARN("GetValue AudioEndpoint_FormFactor failed: 0x%08lx\n", hr);
 176     else if(pvform.vt == VT_UI4)
 177         *formfactor = pvform.ulVal;
 178     else if(pvform.vt == VT_EMPTY)
 179         *formfactor = UnknownFormFactor;
 180     else
 181         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvform.vt);
 182
 183     PropVariantClear(&pvform);
 184     IPropertyStore_Release(ps);
 185 }
 186
 187
 188 static void add_device(IMMDevice *device, LPCWSTR devid, vector_DevMap *list)
 189 {
 190     int count = 0;
 191     al_string tmpname;
 192     DevMap entry;
 193
 194     AL_STRING_INIT(tmpname);
 195     AL_STRING_INIT(entry.name);
 196
 197     entry.devid = strdupW(devid);
 198     get_device_name(device, &tmpname);
 199
 200     while(1)
 201     {
 202         const DevMap *iter;
 203
 204         al_string_copy(&entry.name, tmpname);
 205         if(count != 0)
 206         {
 207             char str[64];
 208             snprintf(str, sizeof(str), " #%d", count+1);
 209             al_string_append_cstr(&entry.name, str);
 210         }
 211
 212 #define MATCH_ENTRY(i) (al_string_cmp(entry.name, (i)->name) == 0)
 213         VECTOR_FIND_IF(iter, const DevMap, *list, MATCH_ENTRY);
 214         if(iter == VECTOR_END(*list)) break;
 215 #undef MATCH_ENTRY
 216         count++;
 217     }
 218
 219     TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
 220     VECTOR_PUSH_BACK(*list, entry);
 221
 222     AL_STRING_DEINIT(tmpname);
 223 }
 224
 225 static LPWSTR get_device_id(IMMDevice *device)
 226 {
 227     LPWSTR devid;
 228     HRESULT hr;
 229
 230     hr = IMMDevice_GetId(device, &devid);
 231     if(FAILED(hr))
 232     {
 233         ERR("Failed to get device id: %lx\n", hr);
 234         return NULL;
 235     }
 236
 237     return devid;
 238 }
 239
 240 static HRESULT probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, vector_DevMap *list)
 241 {
 242     IMMDeviceCollection *coll;
 243     IMMDevice *defdev = NULL;
 244     LPWSTR defdevid = NULL;
 245     HRESULT hr;
 246     UINT count;
 247     UINT i;
 248
 249     hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
 250     if(FAILED(hr))
 251     {
 252         ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
 253         return hr;
 254     }
 255
 256     count = 0;
 257     hr = IMMDeviceCollection_GetCount(coll, &count);
 258     if(SUCCEEDED(hr) && count > 0)
 259     {
 260         clear_devlist(list);
 261         VECTOR_RESIZE(*list, 0, count);
 262
 263         hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
 264                                                          eMultimedia, &defdev);
 265     }
 266     if(SUCCEEDED(hr) && defdev != NULL)
 267     {
 268         defdevid = get_device_id(defdev);
 269         if(defdevid)
 270             add_device(defdev, defdevid, list);
 271     }
 272
 273     for(i = 0;i < count;++i)
 274     {
 275         IMMDevice *device;
 276         LPWSTR devid;
 277
 278         hr = IMMDeviceCollection_Item(coll, i, &device);
 279         if(FAILED(hr)) continue;
 280
 281         devid = get_device_id(device);
 282         if(devid)
 283         {
 284             if(wcscmp(devid, defdevid) != 0)
 285                 add_device(device, devid, list);
 286             CoTaskMemFree(devid);
 287         }
 288         IMMDevice_Release(device);
 289     }
 290
 291     if(defdev) IMMDevice_Release(defdev);
 292     if(defdevid) CoTaskMemFree(defdevid);
 293     IMMDeviceCollection_Release(coll);
 294
 295     return S_OK;
 296 }
 297
 298
 299 /* Proxy interface used by the message handler. */
 300 struct ALCmmdevProxyVtable;
 301
 302 typedef struct ALCmmdevProxy {
 303     const struct ALCmmdevProxyVtable *vtbl;
 304 } ALCmmdevProxy;
 305
 306 struct ALCmmdevProxyVtable {
 307     HRESULT (*const openProxy)(ALCmmdevProxy*);
 308     void (*const closeProxy)(ALCmmdevProxy*);
 309
 310     HRESULT (*const resetProxy)(ALCmmdevProxy*);
 311     HRESULT (*const startProxy)(ALCmmdevProxy*);
 312     void  (*const stopProxy)(ALCmmdevProxy*);
 313 };
 314
 315 #define DEFINE_ALCMMDEVPROXY_VTABLE(T)                                        \
 316 DECLARE_THUNK(T, ALCmmdevProxy, HRESULT, openProxy)                           \
 317 DECLARE_THUNK(T, ALCmmdevProxy, void, closeProxy)                             \
 318 DECLARE_THUNK(T, ALCmmdevProxy, HRESULT, resetProxy)                          \
 319 DECLARE_THUNK(T, ALCmmdevProxy, HRESULT, startProxy)                          \
 320 DECLARE_THUNK(T, ALCmmdevProxy, void, stopProxy)                              \
 321                                                                               \
 322 static const struct ALCmmdevProxyVtable T##_ALCmmdevProxy_vtable = {          \
 323     T##_ALCmmdevProxy_openProxy,                                              \
 324     T##_ALCmmdevProxy_closeProxy,                                             \
 325     T##_ALCmmdevProxy_resetProxy,                                             \
 326     T##_ALCmmdevProxy_startProxy,                                             \
 327     T##_ALCmmdevProxy_stopProxy,                                              \
 328 }
 329
 330 static void ALCmmdevProxy_Construct(ALCmmdevProxy* UNUSED(self)) { }
 331 static void ALCmmdevProxy_Destruct(ALCmmdevProxy* UNUSED(self)) { }
 332
 333 static DWORD CALLBACK ALCmmdevProxy_messageHandler(void *ptr)
 334 {
 335     ThreadRequest *req = ptr;
 336     IMMDeviceEnumerator *Enumerator;
 337     ALuint deviceCount = 0;
 338     ALCmmdevProxy *proxy;
 339     HRESULT hr, cohr;
 340     MSG msg;
 341
 342     TRACE("Starting message thread\n");
 343
 344     cohr = CoInitialize(NULL);
 345     if(FAILED(cohr))
 346     {
 347         WARN("Failed to initialize COM: 0x%08lx\n", cohr);
 348         ReturnMsgResponse(req, cohr);
 349         return 0;
 350     }
 351
 352     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 353     if(FAILED(hr))
 354     {
 355         WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
 356         CoUninitialize();
 357         ReturnMsgResponse(req, hr);
 358         return 0;
 359     }
 360     Enumerator = ptr;
 361     IMMDeviceEnumerator_Release(Enumerator);
 362     Enumerator = NULL;
 363
 364     CoUninitialize();
 365
 366     /* HACK: Force Windows to create a message queue for this thread before
 367      * returning success, otherwise PostThreadMessage may fail if it gets
 368      * called before GetMessage.
 369      */
 370     PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 371
 372     TRACE("Message thread initialization complete\n");
 373     ReturnMsgResponse(req, S_OK);
 374
 375     TRACE("Starting message loop\n");
 376     while(GetMessage(&msg, NULL, WM_USER_First, WM_USER_Last))
 377     {
 378         TRACE("Got message %u (lparam=%p, wparam=%p)\n", msg.message, (void*)msg.lParam, (void*)msg.wParam);
 379         switch(msg.message)
 380         {
 381         case WM_USER_OpenDevice:
 382             req = (ThreadRequest*)msg.wParam;
 383             proxy = (ALCmmdevProxy*)msg.lParam;
 384
 385             hr = cohr = S_OK;
 386             if(++deviceCount == 1)
 387                 hr = cohr = CoInitialize(NULL);
 388             if(SUCCEEDED(hr))
 389                 hr = V0(proxy,openProxy)();
 390             if(FAILED(hr))
 391             {
 392                 if(--deviceCount == 0 && SUCCEEDED(cohr))
 393                     CoUninitialize();
 394             }
 395
 396             ReturnMsgResponse(req, hr);
 397             continue;
 398
 399         case WM_USER_ResetDevice:
 400             req = (ThreadRequest*)msg.wParam;
 401             proxy = (ALCmmdevProxy*)msg.lParam;
 402
 403             hr = V0(proxy,resetProxy)();
 404             ReturnMsgResponse(req, hr);
 405             continue;
 406
 407         case WM_USER_StartDevice:
 408             req = (ThreadRequest*)msg.wParam;
 409             proxy = (ALCmmdevProxy*)msg.lParam;
 410
 411             hr = V0(proxy,startProxy)();
 412             ReturnMsgResponse(req, hr);
 413             continue;
 414
 415         case WM_USER_StopDevice:
 416             req = (ThreadRequest*)msg.wParam;
 417             proxy = (ALCmmdevProxy*)msg.lParam;
 418
 419             V0(proxy,stopProxy)();
 420             ReturnMsgResponse(req, S_OK);
 421             continue;
 422
 423         case WM_USER_CloseDevice:
 424             req = (ThreadRequest*)msg.wParam;
 425             proxy = (ALCmmdevProxy*)msg.lParam;
 426
 427             V0(proxy,closeProxy)();
 428             if(--deviceCount == 0)
 429                 CoUninitialize();
 430
 431             ReturnMsgResponse(req, S_OK);
 432             continue;
 433
 434         case WM_USER_Enumerate:
 435             req = (ThreadRequest*)msg.wParam;
 436
 437             hr = cohr = S_OK;
 438             if(++deviceCount == 1)
 439                 hr = cohr = CoInitialize(NULL);
 440             if(SUCCEEDED(hr))
 441                 hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 442             if(SUCCEEDED(hr))
 443             {
 444                 Enumerator = ptr;
 445
 446                 if(msg.lParam == ALL_DEVICE_PROBE)
 447                     hr = probe_devices(Enumerator, eRender, &PlaybackDevices);
 448                 else if(msg.lParam == CAPTURE_DEVICE_PROBE)
 449                     hr = probe_devices(Enumerator, eCapture, &CaptureDevices);
 450
 451                 IMMDeviceEnumerator_Release(Enumerator);
 452                 Enumerator = NULL;
 453             }
 454
 455             if(--deviceCount == 0 && SUCCEEDED(cohr))
 456                 CoUninitialize();
 457
 458             ReturnMsgResponse(req, hr);
 459             continue;
 460
 461         default:
 462             ERR("Unexpected message: %u\n", msg.message);
 463             continue;
 464         }
 465     }
 466     TRACE("Message loop finished\n");
 467
 468     return 0;
 469 }
 470
 471
 472 typedef struct ALCmmdevPlayback {
 473     DERIVE_FROM_TYPE(ALCbackend);
 474     DERIVE_FROM_TYPE(ALCmmdevProxy);
 475
 476     WCHAR *devid;
 477
 478     IMMDevice *mmdev;
 479     IAudioClient *client;
 480     IAudioRenderClient *render;
 481     HANDLE NotifyEvent;
 482
 483     HANDLE MsgEvent;
 484
 485     volatile UINT32 Padding;
 486
 487     volatile int killNow;
 488     althrd_t thread;
 489 } ALCmmdevPlayback;
 490
 491 static int ALCmmdevPlayback_mixerProc(void *arg);
 492
 493 static void ALCmmdevPlayback_Construct(ALCmmdevPlayback *self, ALCdevice *device);
 494 static void ALCmmdevPlayback_Destruct(ALCmmdevPlayback *self);
 495 static ALCenum ALCmmdevPlayback_open(ALCmmdevPlayback *self, const ALCchar *name);
 496 static HRESULT ALCmmdevPlayback_openProxy(ALCmmdevPlayback *self);
 497 static void ALCmmdevPlayback_close(ALCmmdevPlayback *self);
 498 static void ALCmmdevPlayback_closeProxy(ALCmmdevPlayback *self);
 499 static ALCboolean ALCmmdevPlayback_reset(ALCmmdevPlayback *self);
 500 static HRESULT ALCmmdevPlayback_resetProxy(ALCmmdevPlayback *self);
 501 static ALCboolean ALCmmdevPlayback_start(ALCmmdevPlayback *self);
 502 static HRESULT ALCmmdevPlayback_startProxy(ALCmmdevPlayback *self);
 503 static void ALCmmdevPlayback_stop(ALCmmdevPlayback *self);
 504 static void ALCmmdevPlayback_stopProxy(ALCmmdevPlayback *self);
 505 static DECLARE_FORWARD2(ALCmmdevPlayback, ALCbackend, ALCenum, captureSamples, ALCvoid*, ALCuint)
 506 static DECLARE_FORWARD(ALCmmdevPlayback, ALCbackend, ALCuint, availableSamples)
 507 static ClockLatency ALCmmdevPlayback_getClockLatency(ALCmmdevPlayback *self);
 508 static DECLARE_FORWARD(ALCmmdevPlayback, ALCbackend, void, lock)
 509 static DECLARE_FORWARD(ALCmmdevPlayback, ALCbackend, void, unlock)
 510 DECLARE_DEFAULT_ALLOCATORS(ALCmmdevPlayback)
 511
 512 DEFINE_ALCMMDEVPROXY_VTABLE(ALCmmdevPlayback);
 513 DEFINE_ALCBACKEND_VTABLE(ALCmmdevPlayback);
 514
 515
 516 static void ALCmmdevPlayback_Construct(ALCmmdevPlayback *self, ALCdevice *device)
 517 {
 518     SET_VTABLE2(ALCmmdevPlayback, ALCbackend, self);
 519     SET_VTABLE2(ALCmmdevPlayback, ALCmmdevProxy, self);
 520     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 521     ALCmmdevProxy_Construct(STATIC_CAST(ALCmmdevProxy, self));
 522
 523     self->devid = NULL;
 524
 525     self->mmdev = NULL;
 526     self->client = NULL;
 527     self->render = NULL;
 528     self->NotifyEvent = NULL;
 529
 530     self->MsgEvent = NULL;
 531
 532     self->Padding = 0;
 533
 534     self->killNow = 0;
 535 }
 536
 537 static void ALCmmdevPlayback_Destruct(ALCmmdevPlayback *self)
 538 {
 539     if(self->NotifyEvent != NULL)
 540         CloseHandle(self->NotifyEvent);
 541     self->NotifyEvent = NULL;
 542     if(self->MsgEvent != NULL)
 543         CloseHandle(self->MsgEvent);
 544     self->MsgEvent = NULL;
 545
 546     free(self->devid);
 547     self->devid = NULL;
 548
 549     ALCmmdevProxy_Destruct(STATIC_CAST(ALCmmdevProxy, self));
 550     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
 551 }
 552
 553
 554 FORCE_ALIGN static int ALCmmdevPlayback_mixerProc(void *arg)
 555 {
 556     ALCmmdevPlayback *self = arg;
 557     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 558     UINT32 buffer_len, written;
 559     ALuint update_size, len;
 560     BYTE *buffer;
 561     HRESULT hr;
 562
 563     hr = CoInitialize(NULL);
 564     if(FAILED(hr))
 565     {
 566         ERR("CoInitialize(NULL) failed: 0x%08lx\n", hr);
 567         V0(device->Backend,lock)();
 568         aluHandleDisconnect(device);
 569         V0(device->Backend,unlock)();
 570         return 1;
 571     }
 572
 573     SetRTPriority();
 574     althrd_setname(althrd_current(), MIXER_THREAD_NAME);
 575
 576     update_size = device->UpdateSize;
 577     buffer_len = update_size * device->NumUpdates;
 578     while(!self->killNow)
 579     {
 580         hr = IAudioClient_GetCurrentPadding(self->client, &written);
 581         if(FAILED(hr))
 582         {
 583             ERR("Failed to get padding: 0x%08lx\n", hr);
 584             V0(device->Backend,lock)();
 585             aluHandleDisconnect(device);
 586             V0(device->Backend,unlock)();
 587             break;
 588         }
 589         self->Padding = written;
 590
 591         len = buffer_len - written;
 592         if(len < update_size)
 593         {
 594             DWORD res;
 595             res = WaitForSingleObjectEx(self->NotifyEvent, 2000, FALSE);
 596             if(res != WAIT_OBJECT_0)
 597                 ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
 598             continue;
 599         }
 600         len -= len%update_size;
 601
 602         hr = IAudioRenderClient_GetBuffer(self->render, len, &buffer);
 603         if(SUCCEEDED(hr))
 604         {
 605             V0(device->Backend,lock)();
 606             aluMixData(device, buffer, len);
 607             self->Padding = written + len;
 608             V0(device->Backend,unlock)();
 609             hr = IAudioRenderClient_ReleaseBuffer(self->render, len, 0);
 610         }
 611         if(FAILED(hr))
 612         {
 613             ERR("Failed to buffer data: 0x%08lx\n", hr);
 614             V0(device->Backend,lock)();
 615             aluHandleDisconnect(device);
 616             V0(device->Backend,unlock)();
 617             break;
 618         }
 619     }
 620     self->Padding = 0;
 621
 622     CoUninitialize();
 623     return 0;
 624 }
 625
 626
 627 static ALCboolean MakeExtensible(WAVEFORMATEXTENSIBLE *out, const WAVEFORMATEX *in)
 628 {
 629     memset(out, 0, sizeof(*out));
 630     if(in->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 631         *out = *(const WAVEFORMATEXTENSIBLE*)in;
 632     else if(in->wFormatTag == WAVE_FORMAT_PCM)
 633     {
 634         out->Format = *in;
 635         out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 636         out->Format.cbSize = sizeof(*out) - sizeof(*in);
 637         if(out->Format.nChannels == 1)
 638             out->dwChannelMask = MONO;
 639         else if(out->Format.nChannels == 2)
 640             out->dwChannelMask = STEREO;
 641         else
 642             ERR("Unhandled PCM channel count: %d\n", out->Format.nChannels);
 643         out->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 644     }
 645     else if(in->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 646     {
 647         out->Format = *in;
 648         out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 649         out->Format.cbSize = sizeof(*out) - sizeof(*in);
 650         if(out->Format.nChannels == 1)
 651             out->dwChannelMask = MONO;
 652         else if(out->Format.nChannels == 2)
 653             out->dwChannelMask = STEREO;
 654         else
 655             ERR("Unhandled IEEE float channel count: %d\n", out->Format.nChannels);
 656         out->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 657     }
 658     else
 659     {
 660         ERR("Unhandled format tag: 0x%04x\n", in->wFormatTag);
 661         return ALC_FALSE;
 662     }
 663     return ALC_TRUE;
 664 }
 665
 666
 667 static ALCenum ALCmmdevPlayback_open(ALCmmdevPlayback *self, const ALCchar *deviceName)
 668 {
 669     HRESULT hr = S_OK;
 670
 671     self->NotifyEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 672     self->MsgEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 673     if(self->NotifyEvent == NULL || self->MsgEvent == NULL)
 674     {
 675         ERR("Failed to create message events: %lu\n", GetLastError());
 676         hr = E_FAIL;
 677     }
 678
 679     if(SUCCEEDED(hr))
 680     {
 681         if(deviceName)
 682         {
 683             const DevMap *iter;
 684
 685             if(VECTOR_SIZE(PlaybackDevices) == 0)
 686             {
 687                 ThreadRequest req = { self->MsgEvent, 0 };
 688                 if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, ALL_DEVICE_PROBE))
 689                     (void)WaitForResponse(&req);
 690             }
 691
 692             hr = E_FAIL;
 693 #define MATCH_NAME(i) (al_string_cmp_cstr((i)->name, deviceName) == 0)
 694             VECTOR_FIND_IF(iter, const DevMap, PlaybackDevices, MATCH_NAME);
 695             if(iter == VECTOR_END(PlaybackDevices))
 696                 WARN("Failed to find device name matching \"%s\"\n", deviceName);
 697             else
 698             {
 699                 ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
 700                 self->devid = strdupW(iter->devid);
 701                 al_string_copy(&device->DeviceName, iter->name);
 702                 hr = S_OK;
 703             }
 704 #undef MATCH_NAME
 705         }
 706     }
 707
 708     if(SUCCEEDED(hr))
 709     {
 710         ThreadRequest req = { self->MsgEvent, 0 };
 711
 712         hr = E_FAIL;
 713         if(PostThreadMessage(ThreadID, WM_USER_OpenDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
 714             hr = WaitForResponse(&req);
 715         else
 716             ERR("Failed to post thread message: %lu\n", GetLastError());
 717     }
 718
 719     if(FAILED(hr))
 720     {
 721         if(self->NotifyEvent != NULL)
 722             CloseHandle(self->NotifyEvent);
 723         self->NotifyEvent = NULL;
 724         if(self->MsgEvent != NULL)
 725             CloseHandle(self->MsgEvent);
 726         self->MsgEvent = NULL;
 727
 728         free(self->devid);
 729         self->devid = NULL;
 730
 731         ERR("Device init failed: 0x%08lx\n", hr);
 732         return ALC_INVALID_VALUE;
 733     }
 734
 735     return ALC_NO_ERROR;
 736 }
 737
 738 static HRESULT ALCmmdevPlayback_openProxy(ALCmmdevPlayback *self)
 739 {
 740     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 741     void *ptr;
 742     HRESULT hr;
 743
 744     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 745     if(SUCCEEDED(hr))
 746     {
 747         IMMDeviceEnumerator *Enumerator = ptr;
 748         if(!self->devid)
 749             hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &self->mmdev);
 750         else
 751             hr = IMMDeviceEnumerator_GetDevice(Enumerator, self->devid, &self->mmdev);
 752         IMMDeviceEnumerator_Release(Enumerator);
 753         Enumerator = NULL;
 754     }
 755     if(SUCCEEDED(hr))
 756         hr = IMMDevice_Activate(self->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
 757     if(SUCCEEDED(hr))
 758     {
 759         self->client = ptr;
 760         if(al_string_empty(device->DeviceName))
 761             get_device_name(self->mmdev, &device->DeviceName);
 762     }
 763
 764     if(FAILED(hr))
 765     {
 766         if(self->mmdev)
 767             IMMDevice_Release(self->mmdev);
 768         self->mmdev = NULL;
 769     }
 770
 771     return hr;
 772 }
 773
 774
 775 static void ALCmmdevPlayback_close(ALCmmdevPlayback *self)
 776 {
 777     ThreadRequest req = { self->MsgEvent, 0 };
 778
 779     if(PostThreadMessage(ThreadID, WM_USER_CloseDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
 780         (void)WaitForResponse(&req);
 781
 782     CloseHandle(self->MsgEvent);
 783     self->MsgEvent = NULL;
 784
 785     CloseHandle(self->NotifyEvent);
 786     self->NotifyEvent = NULL;
 787
 788     free(self->devid);
 789     self->devid = NULL;
 790 }
 791
 792 static void ALCmmdevPlayback_closeProxy(ALCmmdevPlayback *self)
 793 {
 794     if(self->client)
 795         IAudioClient_Release(self->client);
 796     self->client = NULL;
 797
 798     if(self->mmdev)
 799         IMMDevice_Release(self->mmdev);
 800     self->mmdev = NULL;
 801 }
 802
 803
 804 static ALCboolean ALCmmdevPlayback_reset(ALCmmdevPlayback *self)
 805 {
 806     ThreadRequest req = { self->MsgEvent, 0 };
 807     HRESULT hr = E_FAIL;
 808
 809     if(PostThreadMessage(ThreadID, WM_USER_ResetDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
 810         hr = WaitForResponse(&req);
 811
 812     return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
 813 }
 814
 815 static HRESULT ALCmmdevPlayback_resetProxy(ALCmmdevPlayback *self)
 816 {
 817     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 818     EndpointFormFactor formfactor = UnknownFormFactor;
 819     WAVEFORMATEXTENSIBLE OutputType;
 820     WAVEFORMATEX *wfx = NULL;
 821     REFERENCE_TIME min_per, buf_time;
 822     UINT32 buffer_len, min_len;
 823     void *ptr = NULL;
 824     HRESULT hr;
 825
 826     if(self->client)
 827         IAudioClient_Release(self->client);
 828     self->client = NULL;
 829
 830     hr = IMMDevice_Activate(self->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
 831     if(FAILED(hr))
 832     {
 833         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
 834         return hr;
 835     }
 836     self->client = ptr;
 837
 838     hr = IAudioClient_GetMixFormat(self->client, &wfx);
 839     if(FAILED(hr))
 840     {
 841         ERR("Failed to get mix format: 0x%08lx\n", hr);
 842         return hr;
 843     }
 844
 845     if(!MakeExtensible(&OutputType, wfx))
 846     {
 847         CoTaskMemFree(wfx);
 848         return E_FAIL;
 849     }
 850     CoTaskMemFree(wfx);
 851     wfx = NULL;
 852
 853     buf_time = ((REFERENCE_TIME)device->UpdateSize*device->NumUpdates*10000000 +
 854                                 device->Frequency-1) / device->Frequency;
 855
 856     if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
 857         device->Frequency = OutputType.Format.nSamplesPerSec;
 858     if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
 859     {
 860         if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
 861             device->FmtChans = DevFmtMono;
 862         else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
 863             device->FmtChans = DevFmtStereo;
 864         else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
 865             device->FmtChans = DevFmtQuad;
 866         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
 867             device->FmtChans = DevFmtX51;
 868         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1REAR)
 869             device->FmtChans = DevFmtX51Rear;
 870         else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
 871             device->FmtChans = DevFmtX61;
 872         else if(OutputType.Format.nChannels == 8 && (OutputType.dwChannelMask == X7DOT1 || OutputType.dwChannelMask == X7DOT1_WIDE))
 873             device->FmtChans = DevFmtX71;
 874         else
 875             ERR("Unhandled channel config: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
 876     }
 877
 878     switch(device->FmtChans)
 879     {
 880         case DevFmtMono:
 881             OutputType.Format.nChannels = 1;
 882             OutputType.dwChannelMask = MONO;
 883             break;
 884         case DevFmtBFormat3D:
 885             device->FmtChans = DevFmtStereo;
 886             /*fall-through*/
 887         case DevFmtStereo:
 888             OutputType.Format.nChannels = 2;
 889             OutputType.dwChannelMask = STEREO;
 890             break;
 891         case DevFmtQuad:
 892             OutputType.Format.nChannels = 4;
 893             OutputType.dwChannelMask = QUAD;
 894             break;
 895         case DevFmtX51:
 896             OutputType.Format.nChannels = 6;
 897             OutputType.dwChannelMask = X5DOT1;
 898             break;
 899         case DevFmtX51Rear:
 900             OutputType.Format.nChannels = 6;
 901             OutputType.dwChannelMask = X5DOT1REAR;
 902             break;
 903         case DevFmtX61:
 904             OutputType.Format.nChannels = 7;
 905             OutputType.dwChannelMask = X6DOT1;
 906             break;
 907         case DevFmtX71:
 908             OutputType.Format.nChannels = 8;
 909             OutputType.dwChannelMask = X7DOT1;
 910             break;
 911     }
 912     switch(device->FmtType)
 913     {
 914         case DevFmtByte:
 915             device->FmtType = DevFmtUByte;
 916             /* fall-through */
 917         case DevFmtUByte:
 918             OutputType.Format.wBitsPerSample = 8;
 919             OutputType.Samples.wValidBitsPerSample = 8;
 920             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 921             break;
 922         case DevFmtUShort:
 923             device->FmtType = DevFmtShort;
 924             /* fall-through */
 925         case DevFmtShort:
 926             OutputType.Format.wBitsPerSample = 16;
 927             OutputType.Samples.wValidBitsPerSample = 16;
 928             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 929             break;
 930         case DevFmtUInt:
 931             device->FmtType = DevFmtInt;
 932             /* fall-through */
 933         case DevFmtInt:
 934             OutputType.Format.wBitsPerSample = 32;
 935             OutputType.Samples.wValidBitsPerSample = 32;
 936             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 937             break;
 938         case DevFmtFloat:
 939             OutputType.Format.wBitsPerSample = 32;
 940             OutputType.Samples.wValidBitsPerSample = 32;
 941             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 942             break;
 943     }
 944     OutputType.Format.nSamplesPerSec = device->Frequency;
 945
 946     OutputType.Format.nBlockAlign = OutputType.Format.nChannels *
 947                                     OutputType.Format.wBitsPerSample / 8;
 948     OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
 949                                         OutputType.Format.nBlockAlign;
 950
 951     hr = IAudioClient_IsFormatSupported(self->client, AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
 952     if(FAILED(hr))
 953     {
 954         ERR("Failed to check format support: 0x%08lx\n", hr);
 955         hr = IAudioClient_GetMixFormat(self->client, &wfx);
 956     }
 957     if(FAILED(hr))
 958     {
 959         ERR("Failed to find a supported format: 0x%08lx\n", hr);
 960         return hr;
 961     }
 962
 963     if(wfx != NULL)
 964     {
 965         if(!MakeExtensible(&OutputType, wfx))
 966         {
 967             CoTaskMemFree(wfx);
 968             return E_FAIL;
 969         }
 970         CoTaskMemFree(wfx);
 971         wfx = NULL;
 972
 973         device->Frequency = OutputType.Format.nSamplesPerSec;
 974         if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
 975             device->FmtChans = DevFmtMono;
 976         else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
 977             device->FmtChans = DevFmtStereo;
 978         else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
 979             device->FmtChans = DevFmtQuad;
 980         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
 981             device->FmtChans = DevFmtX51;
 982         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1REAR)
 983             device->FmtChans = DevFmtX51Rear;
 984         else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
 985             device->FmtChans = DevFmtX61;
 986         else if(OutputType.Format.nChannels == 8 && (OutputType.dwChannelMask == X7DOT1 || OutputType.dwChannelMask == X7DOT1_WIDE))
 987             device->FmtChans = DevFmtX71;
 988         else
 989         {
 990             ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
 991             device->FmtChans = DevFmtStereo;
 992             OutputType.Format.nChannels = 2;
 993             OutputType.dwChannelMask = STEREO;
 994         }
 995
 996         if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 997         {
 998             if(OutputType.Format.wBitsPerSample == 8)
 999                 device->FmtType = DevFmtUByte;
1000             else if(OutputType.Format.wBitsPerSample == 16)
1001                 device->FmtType = DevFmtShort;
1002             else if(OutputType.Format.wBitsPerSample == 32)
1003                 device->FmtType = DevFmtInt;
1004             else
1005             {
1006                 device->FmtType = DevFmtShort;
1007                 OutputType.Format.wBitsPerSample = 16;
1008             }
1009         }
1010         else if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
1011         {
1012             device->FmtType = DevFmtFloat;
1013             OutputType.Format.wBitsPerSample = 32;
1014         }
1015         else
1016         {
1017             ERR("Unhandled format sub-type\n");
1018             device->FmtType = DevFmtShort;
1019             OutputType.Format.wBitsPerSample = 16;
1020             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1021         }
1022         OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
1023     }
1024     get_device_formfactor(self->mmdev, &formfactor);
1025     device->IsHeadphones = (device->FmtChans == DevFmtStereo && formfactor == Headphones);
1026
1027     SetDefaultWFXChannelOrder(device);
1028
1029     hr = IAudioClient_Initialize(self->client, AUDCLNT_SHAREMODE_SHARED,
1030                                  AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
1031                                  buf_time, 0, &OutputType.Format, NULL);
1032     if(FAILED(hr))
1033     {
1034         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
1035         return hr;
1036     }
1037
1038     hr = IAudioClient_GetDevicePeriod(self->client, &min_per, NULL);
1039     if(SUCCEEDED(hr))
1040     {
1041         min_len = (UINT32)((min_per*device->Frequency + 10000000-1) / 10000000);
1042         /* Find the nearest multiple of the period size to the update size */
1043         if(min_len < device->UpdateSize)
1044             min_len *= (device->UpdateSize + min_len/2)/min_len;
1045         hr = IAudioClient_GetBufferSize(self->client, &buffer_len);
1046     }
1047     if(FAILED(hr))
1048     {
1049         ERR("Failed to get audio buffer info: 0x%08lx\n", hr);
1050         return hr;
1051     }
1052
1053     device->UpdateSize = min_len;
1054     device->NumUpdates = buffer_len / device->UpdateSize;
1055     if(device->NumUpdates <= 1)
1056     {
1057         ERR("Audio client returned buffer_len < period*2; expect break up\n");
1058         device->NumUpdates = 2;
1059         device->UpdateSize = buffer_len / device->NumUpdates;
1060     }
1061
1062     hr = IAudioClient_SetEventHandle(self->client, self->NotifyEvent);
1063     if(FAILED(hr))
1064     {
1065         ERR("Failed to set event handle: 0x%08lx\n", hr);
1066         return hr;
1067     }
1068
1069     return hr;
1070 }
1071
1072
1073 static ALCboolean ALCmmdevPlayback_start(ALCmmdevPlayback *self)
1074 {
1075     ThreadRequest req = { self->MsgEvent, 0 };
1076     HRESULT hr = E_FAIL;
1077
1078     if(PostThreadMessage(ThreadID, WM_USER_StartDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1079         hr = WaitForResponse(&req);
1080
1081     return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
1082 }
1083
1084 static HRESULT ALCmmdevPlayback_startProxy(ALCmmdevPlayback *self)
1085 {
1086     HRESULT hr;
1087     void *ptr;
1088
1089     ResetEvent(self->NotifyEvent);
1090     hr = IAudioClient_Start(self->client);
1091     if(FAILED(hr))
1092         ERR("Failed to start audio client: 0x%08lx\n", hr);
1093
1094     if(SUCCEEDED(hr))
1095         hr = IAudioClient_GetService(self->client, &IID_IAudioRenderClient, &ptr);
1096     if(SUCCEEDED(hr))
1097     {
1098         self->render = ptr;
1099         self->killNow = 0;
1100         if(althrd_create(&self->thread, ALCmmdevPlayback_mixerProc, self) != althrd_success)
1101         {
1102             if(self->render)
1103                 IAudioRenderClient_Release(self->render);
1104             self->render = NULL;
1105             IAudioClient_Stop(self->client);
1106             ERR("Failed to start thread\n");
1107             hr = E_FAIL;
1108         }
1109     }
1110
1111     return hr;
1112 }
1113
1114
1115 static void ALCmmdevPlayback_stop(ALCmmdevPlayback *self)
1116 {
1117     ThreadRequest req = { self->MsgEvent, 0 };
1118     if(PostThreadMessage(ThreadID, WM_USER_StopDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1119         (void)WaitForResponse(&req);
1120 }
1121
1122 static void ALCmmdevPlayback_stopProxy(ALCmmdevPlayback *self)
1123 {
1124     int res;
1125
1126     if(!self->render)
1127         return;
1128
1129     self->killNow = 1;
1130     althrd_join(self->thread, &res);
1131
1132     IAudioRenderClient_Release(self->render);
1133     self->render = NULL;
1134     IAudioClient_Stop(self->client);
1135 }
1136
1137
1138 static ClockLatency ALCmmdevPlayback_getClockLatency(ALCmmdevPlayback *self)
1139 {
1140     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1141     ClockLatency ret;
1142
1143     ALCmmdevPlayback_lock(self);
1144     ret.ClockTime = GetDeviceClockTime(device);
1145     ret.Latency = self->Padding * DEVICE_CLOCK_RES / device->Frequency;
1146     ALCmmdevPlayback_unlock(self);
1147
1148     return ret;
1149 }
1150
1151
1152 typedef struct ALCmmdevCapture {
1153     DERIVE_FROM_TYPE(ALCbackend);
1154     DERIVE_FROM_TYPE(ALCmmdevProxy);
1155
1156     WCHAR *devid;
1157
1158     IMMDevice *mmdev;
1159     IAudioClient *client;
1160     IAudioCaptureClient *capture;
1161     HANDLE NotifyEvent;
1162
1163     HANDLE MsgEvent;
1164
1165     ll_ringbuffer_t *Ring;
1166
1167     volatile int killNow;
1168     althrd_t thread;
1169 } ALCmmdevCapture;
1170
1171 static int ALCmmdevCapture_recordProc(void *arg);
1172
1173 static void ALCmmdevCapture_Construct(ALCmmdevCapture *self, ALCdevice *device);
1174 static void ALCmmdevCapture_Destruct(ALCmmdevCapture *self);
1175 static ALCenum ALCmmdevCapture_open(ALCmmdevCapture *self, const ALCchar *name);
1176 static HRESULT ALCmmdevCapture_openProxy(ALCmmdevCapture *self);
1177 static void ALCmmdevCapture_close(ALCmmdevCapture *self);
1178 static void ALCmmdevCapture_closeProxy(ALCmmdevCapture *self);
1179 static DECLARE_FORWARD(ALCmmdevCapture, ALCbackend, ALCboolean, reset)
1180 static HRESULT ALCmmdevCapture_resetProxy(ALCmmdevCapture *self);
1181 static ALCboolean ALCmmdevCapture_start(ALCmmdevCapture *self);
1182 static HRESULT ALCmmdevCapture_startProxy(ALCmmdevCapture *self);
1183 static void ALCmmdevCapture_stop(ALCmmdevCapture *self);
1184 static void ALCmmdevCapture_stopProxy(ALCmmdevCapture *self);
1185 static ALCenum ALCmmdevCapture_captureSamples(ALCmmdevCapture *self, ALCvoid *buffer, ALCuint samples);
1186 static ALuint ALCmmdevCapture_availableSamples(ALCmmdevCapture *self);
1187 static DECLARE_FORWARD(ALCmmdevCapture, ALCbackend, ClockLatency, getClockLatency)
1188 static DECLARE_FORWARD(ALCmmdevCapture, ALCbackend, void, lock)
1189 static DECLARE_FORWARD(ALCmmdevCapture, ALCbackend, void, unlock)
1190 DECLARE_DEFAULT_ALLOCATORS(ALCmmdevCapture)
1191
1192 DEFINE_ALCMMDEVPROXY_VTABLE(ALCmmdevCapture);
1193 DEFINE_ALCBACKEND_VTABLE(ALCmmdevCapture);
1194
1195
1196 static void ALCmmdevCapture_Construct(ALCmmdevCapture *self, ALCdevice *device)
1197 {
1198     SET_VTABLE2(ALCmmdevCapture, ALCbackend, self);
1199     SET_VTABLE2(ALCmmdevCapture, ALCmmdevProxy, self);
1200     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
1201     ALCmmdevProxy_Construct(STATIC_CAST(ALCmmdevProxy, self));
1202
1203     self->devid = NULL;
1204
1205     self->mmdev = NULL;
1206     self->client = NULL;
1207     self->capture = NULL;
1208     self->NotifyEvent = NULL;
1209
1210     self->MsgEvent = NULL;
1211
1212     self->Ring = NULL;
1213
1214     self->killNow = 0;
1215 }
1216
1217 static void ALCmmdevCapture_Destruct(ALCmmdevCapture *self)
1218 {
1219     ll_ringbuffer_free(self->Ring);
1220     self->Ring = NULL;
1221
1222     if(self->NotifyEvent != NULL)
1223         CloseHandle(self->NotifyEvent);
1224     self->NotifyEvent = NULL;
1225     if(self->MsgEvent != NULL)
1226         CloseHandle(self->MsgEvent);
1227     self->MsgEvent = NULL;
1228
1229     free(self->devid);
1230     self->devid = NULL;
1231
1232     ALCmmdevProxy_Destruct(STATIC_CAST(ALCmmdevProxy, self));
1233     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
1234 }
1235
1236
1237 FORCE_ALIGN int ALCmmdevCapture_recordProc(void *arg)
1238 {
1239     ALCmmdevCapture *self = arg;
1240     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1241     HRESULT hr;
1242
1243     hr = CoInitialize(NULL);
1244     if(FAILED(hr))
1245     {
1246         ERR("CoInitialize(NULL) failed: 0x%08lx\n", hr);
1247         V0(device->Backend,lock)();
1248         aluHandleDisconnect(device);
1249         V0(device->Backend,unlock)();
1250         return 1;
1251     }
1252
1253     althrd_setname(althrd_current(), RECORD_THREAD_NAME);
1254
1255     while(!self->killNow)
1256     {
1257         UINT32 avail;
1258         DWORD res;
1259
1260         hr = IAudioCaptureClient_GetNextPacketSize(self->capture, &avail);
1261         if(FAILED(hr))
1262             ERR("Failed to get next packet size: 0x%08lx\n", hr);
1263         else while(avail > 0 && SUCCEEDED(hr))
1264         {
1265             UINT32 numsamples;
1266             DWORD flags;
1267             BYTE *data;
1268
1269             hr = IAudioCaptureClient_GetBuffer(self->capture,
1270                 &data, &numsamples, &flags, NULL, NULL
1271             );
1272             if(FAILED(hr))
1273             {
1274                 ERR("Failed to get capture buffer: 0x%08lx\n", hr);
1275                 break;
1276             }
1277
1278             ll_ringbuffer_write(self->Ring, (char*)data, numsamples);
1279
1280             hr = IAudioCaptureClient_ReleaseBuffer(self->capture, numsamples);
1281             if(FAILED(hr))
1282             {
1283                 ERR("Failed to release capture buffer: 0x%08lx\n", hr);
1284                 break;
1285             }
1286
1287             hr = IAudioCaptureClient_GetNextPacketSize(self->capture, &avail);
1288             if(FAILED(hr))
1289                 ERR("Failed to get next packet size: 0x%08lx\n", hr);
1290         }
1291
1292         if(FAILED(hr))
1293         {
1294             V0(device->Backend,lock)();
1295             aluHandleDisconnect(device);
1296             V0(device->Backend,unlock)();
1297             break;
1298         }
1299
1300         res = WaitForSingleObjectEx(self->NotifyEvent, 2000, FALSE);
1301         if(res != WAIT_OBJECT_0)
1302             ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
1303     }
1304
1305     CoUninitialize();
1306     return 0;
1307 }
1308
1309
1310 static ALCenum ALCmmdevCapture_open(ALCmmdevCapture *self, const ALCchar *deviceName)
1311 {
1312     HRESULT hr = S_OK;
1313
1314     self->NotifyEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1315     self->MsgEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1316     if(self->NotifyEvent == NULL || self->MsgEvent == NULL)
1317     {
1318         ERR("Failed to create message events: %lu\n", GetLastError());
1319         hr = E_FAIL;
1320     }
1321
1322     if(SUCCEEDED(hr))
1323     {
1324         if(deviceName)
1325         {
1326             const DevMap *iter;
1327
1328             if(VECTOR_SIZE(CaptureDevices) == 0)
1329             {
1330                 ThreadRequest req = { self->MsgEvent, 0 };
1331                 if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, CAPTURE_DEVICE_PROBE))
1332                     (void)WaitForResponse(&req);
1333             }
1334
1335             hr = E_FAIL;
1336 #define MATCH_NAME(i) (al_string_cmp_cstr((i)->name, deviceName) == 0)
1337             VECTOR_FIND_IF(iter, const DevMap, CaptureDevices, MATCH_NAME);
1338             if(iter == VECTOR_END(CaptureDevices))
1339                 WARN("Failed to find device name matching \"%s\"\n", deviceName);
1340             else
1341             {
1342                 ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
1343                 self->devid = strdupW(iter->devid);
1344                 al_string_copy(&device->DeviceName, iter->name);
1345                 hr = S_OK;
1346             }
1347 #undef MATCH_NAME
1348         }
1349     }
1350
1351     if(SUCCEEDED(hr))
1352     {
1353         ThreadRequest req = { self->MsgEvent, 0 };
1354
1355         hr = E_FAIL;
1356         if(PostThreadMessage(ThreadID, WM_USER_OpenDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1357             hr = WaitForResponse(&req);
1358         else
1359             ERR("Failed to post thread message: %lu\n", GetLastError());
1360     }
1361
1362     if(FAILED(hr))
1363     {
1364         if(self->NotifyEvent != NULL)
1365             CloseHandle(self->NotifyEvent);
1366         self->NotifyEvent = NULL;
1367         if(self->MsgEvent != NULL)
1368             CloseHandle(self->MsgEvent);
1369         self->MsgEvent = NULL;
1370
1371         free(self->devid);
1372         self->devid = NULL;
1373
1374         ERR("Device init failed: 0x%08lx\n", hr);
1375         return ALC_INVALID_VALUE;
1376     }
1377     else
1378     {
1379         ThreadRequest req = { self->MsgEvent, 0 };
1380
1381         hr = E_FAIL;
1382         if(PostThreadMessage(ThreadID, WM_USER_ResetDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1383             hr = WaitForResponse(&req);
1384         else
1385             ERR("Failed to post thread message: %lu\n", GetLastError());
1386
1387         if(FAILED(hr))
1388         {
1389             ALCmmdevCapture_close(self);
1390             if(hr == E_OUTOFMEMORY)
1391                return ALC_OUT_OF_MEMORY;
1392             return ALC_INVALID_VALUE;
1393         }
1394     }
1395
1396     return ALC_NO_ERROR;
1397 }
1398
1399 static HRESULT ALCmmdevCapture_openProxy(ALCmmdevCapture *self)
1400 {
1401     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1402     void *ptr;
1403     HRESULT hr;
1404
1405     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
1406     if(SUCCEEDED(hr))
1407     {
1408         IMMDeviceEnumerator *Enumerator = ptr;
1409         if(!self->devid)
1410             hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eCapture, eMultimedia, &self->mmdev);
1411         else
1412             hr = IMMDeviceEnumerator_GetDevice(Enumerator, self->devid, &self->mmdev);
1413         IMMDeviceEnumerator_Release(Enumerator);
1414         Enumerator = NULL;
1415     }
1416     if(SUCCEEDED(hr))
1417         hr = IMMDevice_Activate(self->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
1418     if(SUCCEEDED(hr))
1419     {
1420         self->client = ptr;
1421         if(al_string_empty(device->DeviceName))
1422             get_device_name(self->mmdev, &device->DeviceName);
1423     }
1424
1425     if(FAILED(hr))
1426     {
1427         if(self->mmdev)
1428             IMMDevice_Release(self->mmdev);
1429         self->mmdev = NULL;
1430     }
1431
1432     return hr;
1433 }
1434
1435
1436 static void ALCmmdevCapture_close(ALCmmdevCapture *self)
1437 {
1438     ThreadRequest req = { self->MsgEvent, 0 };
1439
1440     if(PostThreadMessage(ThreadID, WM_USER_CloseDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1441         (void)WaitForResponse(&req);
1442
1443     ll_ringbuffer_free(self->Ring);
1444     self->Ring = NULL;
1445
1446     CloseHandle(self->MsgEvent);
1447     self->MsgEvent = NULL;
1448
1449     CloseHandle(self->NotifyEvent);
1450     self->NotifyEvent = NULL;
1451
1452     free(self->devid);
1453     self->devid = NULL;
1454 }
1455
1456 static void ALCmmdevCapture_closeProxy(ALCmmdevCapture *self)
1457 {
1458     if(self->client)
1459         IAudioClient_Release(self->client);
1460     self->client = NULL;
1461
1462     if(self->mmdev)
1463         IMMDevice_Release(self->mmdev);
1464     self->mmdev = NULL;
1465 }
1466
1467
1468 static HRESULT ALCmmdevCapture_resetProxy(ALCmmdevCapture *self)
1469 {
1470     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1471     WAVEFORMATEXTENSIBLE OutputType;
1472     WAVEFORMATEX *wfx = NULL;
1473     REFERENCE_TIME buf_time;
1474     UINT32 buffer_len;
1475     void *ptr = NULL;
1476     HRESULT hr;
1477
1478     if(self->client)
1479         IAudioClient_Release(self->client);
1480     self->client = NULL;
1481
1482     hr = IMMDevice_Activate(self->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
1483     if(FAILED(hr))
1484     {
1485         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
1486         return hr;
1487     }
1488     self->client = ptr;
1489
1490     buf_time = ((REFERENCE_TIME)device->UpdateSize*device->NumUpdates*10000000 +
1491                                 device->Frequency-1) / device->Frequency;
1492
1493     OutputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
1494     switch(device->FmtChans)
1495     {
1496         case DevFmtMono:
1497             OutputType.Format.nChannels = 1;
1498             OutputType.dwChannelMask = MONO;
1499             break;
1500         case DevFmtStereo:
1501             OutputType.Format.nChannels = 2;
1502             OutputType.dwChannelMask = STEREO;
1503             break;
1504         case DevFmtQuad:
1505             OutputType.Format.nChannels = 4;
1506             OutputType.dwChannelMask = QUAD;
1507             break;
1508         case DevFmtX51:
1509             OutputType.Format.nChannels = 6;
1510             OutputType.dwChannelMask = X5DOT1;
1511             break;
1512         case DevFmtX51Rear:
1513             OutputType.Format.nChannels = 6;
1514             OutputType.dwChannelMask = X5DOT1REAR;
1515             break;
1516         case DevFmtX61:
1517             OutputType.Format.nChannels = 7;
1518             OutputType.dwChannelMask = X6DOT1;
1519             break;
1520         case DevFmtX71:
1521             OutputType.Format.nChannels = 8;
1522             OutputType.dwChannelMask = X7DOT1;
1523             break;
1524
1525         case DevFmtBFormat3D:
1526             return E_FAIL;
1527     }
1528     switch(device->FmtType)
1529     {
1530         case DevFmtUByte:
1531             OutputType.Format.wBitsPerSample = 8;
1532             OutputType.Samples.wValidBitsPerSample = 8;
1533             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1534             break;
1535         case DevFmtShort:
1536             OutputType.Format.wBitsPerSample = 16;
1537             OutputType.Samples.wValidBitsPerSample = 16;
1538             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1539             break;
1540         case DevFmtInt:
1541             OutputType.Format.wBitsPerSample = 32;
1542             OutputType.Samples.wValidBitsPerSample = 32;
1543             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1544             break;
1545         case DevFmtFloat:
1546             OutputType.Format.wBitsPerSample = 32;
1547             OutputType.Samples.wValidBitsPerSample = 32;
1548             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1549             break;
1550
1551         case DevFmtByte:
1552         case DevFmtUShort:
1553         case DevFmtUInt:
1554             WARN("%s capture samples not supported\n", DevFmtTypeString(device->FmtType));
1555             return E_FAIL;
1556     }
1557     OutputType.Format.nSamplesPerSec = device->Frequency;
1558
1559     OutputType.Format.nBlockAlign = OutputType.Format.nChannels *
1560                                     OutputType.Format.wBitsPerSample / 8;
1561     OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
1562                                         OutputType.Format.nBlockAlign;
1563     OutputType.Format.cbSize = sizeof(OutputType) - sizeof(OutputType.Format);
1564
1565     hr = IAudioClient_IsFormatSupported(self->client,
1566         AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx
1567     );
1568     if(FAILED(hr))
1569     {
1570         ERR("Failed to check format support: 0x%08lx\n", hr);
1571         return hr;
1572     }
1573
1574     /* FIXME: We should do conversion/resampling if we didn't get a matching format. */
1575     if(wfx->nSamplesPerSec != OutputType.Format.nSamplesPerSec ||
1576        wfx->wBitsPerSample != OutputType.Format.wBitsPerSample ||
1577        wfx->nChannels != OutputType.Format.nChannels ||
1578        wfx->nBlockAlign != OutputType.Format.nBlockAlign)
1579     {
1580         ERR("Failed to get matching format, wanted: %s %s %uhz, got: %d channel%s %d-bit %luhz\n",
1581             DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
1582             device->Frequency, wfx->nChannels, (wfx->nChannels==1)?"":"s", wfx->wBitsPerSample,
1583             wfx->nSamplesPerSec);
1584         CoTaskMemFree(wfx);
1585         return E_FAIL;
1586     }
1587
1588     if(!MakeExtensible(&OutputType, wfx))
1589     {
1590         CoTaskMemFree(wfx);
1591         return E_FAIL;
1592     }
1593     CoTaskMemFree(wfx);
1594     wfx = NULL;
1595
1596     hr = IAudioClient_Initialize(self->client,
1597         AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
1598         buf_time, 0, &OutputType.Format, NULL
1599     );
1600     if(FAILED(hr))
1601     {
1602         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
1603         return hr;
1604     }
1605
1606     hr = IAudioClient_GetBufferSize(self->client, &buffer_len);
1607     if(FAILED(hr))
1608     {
1609         ERR("Failed to get buffer size: 0x%08lx\n", hr);
1610         return hr;
1611     }
1612
1613     buffer_len = maxu(device->UpdateSize*device->NumUpdates + 1, buffer_len);
1614     ll_ringbuffer_free(self->Ring);
1615     self->Ring = ll_ringbuffer_create(buffer_len, OutputType.Format.nBlockAlign);
1616     if(!self->Ring)
1617     {
1618         ERR("Failed to allocate capture ring buffer\n");
1619         return E_OUTOFMEMORY;
1620     }
1621
1622     hr = IAudioClient_SetEventHandle(self->client, self->NotifyEvent);
1623     if(FAILED(hr))
1624     {
1625         ERR("Failed to set event handle: 0x%08lx\n", hr);
1626         return hr;
1627     }
1628
1629     return hr;
1630 }
1631
1632
1633 static ALCboolean ALCmmdevCapture_start(ALCmmdevCapture *self)
1634 {
1635     ThreadRequest req = { self->MsgEvent, 0 };
1636     HRESULT hr = E_FAIL;
1637
1638     if(PostThreadMessage(ThreadID, WM_USER_StartDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1639         hr = WaitForResponse(&req);
1640
1641     return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
1642 }
1643
1644 static HRESULT ALCmmdevCapture_startProxy(ALCmmdevCapture *self)
1645 {
1646     HRESULT hr;
1647     void *ptr;
1648
1649     ResetEvent(self->NotifyEvent);
1650     hr = IAudioClient_Start(self->client);
1651     if(FAILED(hr))
1652     {
1653         ERR("Failed to start audio client: 0x%08lx\n", hr);
1654         return hr;
1655     }
1656
1657     hr = IAudioClient_GetService(self->client, &IID_IAudioCaptureClient, &ptr);
1658     if(SUCCEEDED(hr))
1659     {
1660         self->capture = ptr;
1661         self->killNow = 0;
1662         if(althrd_create(&self->thread, ALCmmdevCapture_recordProc, self) != althrd_success)
1663         {
1664             ERR("Failed to start thread\n");
1665             IAudioCaptureClient_Release(self->capture);
1666             self->capture = NULL;
1667             hr = E_FAIL;
1668         }
1669     }
1670
1671     if(FAILED(hr))
1672     {
1673         IAudioClient_Stop(self->client);
1674         IAudioClient_Reset(self->client);
1675     }
1676
1677     return hr;
1678 }
1679
1680
1681 static void ALCmmdevCapture_stop(ALCmmdevCapture *self)
1682 {
1683     ThreadRequest req = { self->MsgEvent, 0 };
1684     if(PostThreadMessage(ThreadID, WM_USER_StopDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1685         (void)WaitForResponse(&req);
1686 }
1687
1688 static void ALCmmdevCapture_stopProxy(ALCmmdevCapture *self)
1689 {
1690     int res;
1691
1692     if(!self->capture)
1693         return;
1694
1695     self->killNow = 1;
1696     althrd_join(self->thread, &res);
1697
1698     IAudioCaptureClient_Release(self->capture);
1699     self->capture = NULL;
1700     IAudioClient_Stop(self->client);
1701     IAudioClient_Reset(self->client);
1702 }
1703
1704
1705 ALuint ALCmmdevCapture_availableSamples(ALCmmdevCapture *self)
1706 {
1707     return (ALuint)ll_ringbuffer_read_space(self->Ring);
1708 }
1709
1710 ALCenum ALCmmdevCapture_captureSamples(ALCmmdevCapture *self, ALCvoid *buffer, ALCuint samples)
1711 {
1712     if(ALCmmdevCapture_availableSamples(self) < samples)
1713         return ALC_INVALID_VALUE;
1714     ll_ringbuffer_read(self->Ring, buffer, samples);
1715     return ALC_NO_ERROR;
1716 }
1717
1718
1719 static inline void AppendAllDevicesList2(const DevMap *entry)
1720 { AppendAllDevicesList(al_string_get_cstr(entry->name)); }
1721 static inline void AppendCaptureDeviceList2(const DevMap *entry)
1722 { AppendCaptureDeviceList(al_string_get_cstr(entry->name)); }
1723
1724 typedef struct ALCmmdevBackendFactory {
1725     DERIVE_FROM_TYPE(ALCbackendFactory);
1726 } ALCmmdevBackendFactory;
1727 #define ALCMMDEVBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCmmdevBackendFactory, ALCbackendFactory) } }
1728
1729 static ALCboolean ALCmmdevBackendFactory_init(ALCmmdevBackendFactory *self);
1730 static void ALCmmdevBackendFactory_deinit(ALCmmdevBackendFactory *self);
1731 static ALCboolean ALCmmdevBackendFactory_querySupport(ALCmmdevBackendFactory *self, ALCbackend_Type type);
1732 static void ALCmmdevBackendFactory_probe(ALCmmdevBackendFactory *self, enum DevProbe type);
1733 static ALCbackend* ALCmmdevBackendFactory_createBackend(ALCmmdevBackendFactory *self, ALCdevice *device, ALCbackend_Type type);
1734
1735 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCmmdevBackendFactory);
1736
1737
1738 static BOOL MMDevApiLoad(void)
1739 {
1740     static HRESULT InitResult;
1741     if(!ThreadHdl)
1742     {
1743         ThreadRequest req;
1744         InitResult = E_FAIL;
1745
1746         req.FinishedEvt = CreateEventW(NULL, FALSE, FALSE, NULL);
1747         if(req.FinishedEvt == NULL)
1748             ERR("Failed to create event: %lu\n", GetLastError());
1749         else
1750         {
1751             ThreadHdl = CreateThread(NULL, 0, ALCmmdevProxy_messageHandler, &req, 0, &ThreadID);
1752             if(ThreadHdl != NULL)
1753                 InitResult = WaitForResponse(&req);
1754             CloseHandle(req.FinishedEvt);
1755         }
1756     }
1757     return SUCCEEDED(InitResult);
1758 }
1759
1760 static ALCboolean ALCmmdevBackendFactory_init(ALCmmdevBackendFactory* UNUSED(self))
1761 {
1762     VECTOR_INIT(PlaybackDevices);
1763     VECTOR_INIT(CaptureDevices);
1764
1765     if(!MMDevApiLoad())
1766         return ALC_FALSE;
1767     return ALC_TRUE;
1768 }
1769
1770 static void ALCmmdevBackendFactory_deinit(ALCmmdevBackendFactory* UNUSED(self))
1771 {
1772     clear_devlist(&PlaybackDevices);
1773     VECTOR_DEINIT(PlaybackDevices);
1774
1775     clear_devlist(&CaptureDevices);
1776     VECTOR_DEINIT(CaptureDevices);
1777
1778     if(ThreadHdl)
1779     {
1780         TRACE("Sending WM_QUIT to Thread %04lx\n", ThreadID);
1781         PostThreadMessage(ThreadID, WM_QUIT, 0, 0);
1782         CloseHandle(ThreadHdl);
1783         ThreadHdl = NULL;
1784     }
1785 }
1786
1787 static ALCboolean ALCmmdevBackendFactory_querySupport(ALCmmdevBackendFactory* UNUSED(self), ALCbackend_Type type)
1788 {
1789     /* TODO: Disable capture with mmdevapi for now, since it doesn't do any
1790      * rechanneling or resampling; if the device is configured for 48000hz
1791      * stereo input, for example, and the app asks for 22050hz mono,
1792      * initialization will fail.
1793      */
1794     if(type == ALCbackend_Playback /*|| type == ALCbackend_Capture*/)
1795         return ALC_TRUE;
1796     return ALC_FALSE;
1797 }
1798
1799 static void ALCmmdevBackendFactory_probe(ALCmmdevBackendFactory* UNUSED(self), enum DevProbe type)
1800 {
1801     ThreadRequest req = { NULL, 0 };
1802
1803     req.FinishedEvt = CreateEventW(NULL, FALSE, FALSE, NULL);
1804     if(req.FinishedEvt == NULL)
1805         ERR("Failed to create event: %lu\n", GetLastError());
1806     else
1807     {
1808         HRESULT hr = E_FAIL;
1809         if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, type))
1810             hr = WaitForResponse(&req);
1811         if(SUCCEEDED(hr)) switch(type)
1812         {
1813         case ALL_DEVICE_PROBE:
1814             VECTOR_FOR_EACH(const DevMap, PlaybackDevices, AppendAllDevicesList2);
1815             break;
1816
1817         case CAPTURE_DEVICE_PROBE:
1818             VECTOR_FOR_EACH(const DevMap, CaptureDevices, AppendCaptureDeviceList2);
1819             break;
1820         }
1821         CloseHandle(req.FinishedEvt);
1822         req.FinishedEvt = NULL;
1823     }
1824 }
1825
1826 static ALCbackend* ALCmmdevBackendFactory_createBackend(ALCmmdevBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
1827 {
1828     if(type == ALCbackend_Playback)
1829     {
1830         ALCmmdevPlayback *backend;
1831         NEW_OBJ(backend, ALCmmdevPlayback)(device);
1832         if(!backend) return NULL;
1833         return STATIC_CAST(ALCbackend, backend);
1834     }
1835     if(type == ALCbackend_Capture)
1836     {
1837         ALCmmdevCapture *backend;
1838         NEW_OBJ(backend, ALCmmdevCapture)(device);
1839         if(!backend) return NULL;
1840         return STATIC_CAST(ALCbackend, backend);
1841     }
1842
1843     return NULL;
1844 }
1845
1846
1847 ALCbackendFactory *ALCmmdevBackendFactory_getFactory(void)
1848 {
1849     static ALCmmdevBackendFactory factory = ALCMMDEVBACKENDFACTORY_INITIALIZER;
1850     return STATIC_CAST(ALCbackendFactory, &factory);
1851 }