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
  55 #define MONO SPEAKER_FRONT_CENTER
  56 #define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
  57 #define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  58 #define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  59 #define X5DOT1REAR (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  60 #define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  61 #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)
  62
  63
  64 typedef struct {
  65     al_string name;
  66     WCHAR *devid;
  67 } DevMap;
  68 TYPEDEF_VECTOR(DevMap, vector_DevMap)
  69
  70 static void clear_devlist(vector_DevMap *list)
  71 {
  72     DevMap *iter, *end;
  73
  74     iter = VECTOR_ITER_BEGIN(*list);
  75     end = VECTOR_ITER_END(*list);
  76     for(;iter != end;iter++)
  77     {
  78         AL_STRING_DEINIT(iter->name);
  79         free(iter->devid);
  80     }
  81     VECTOR_RESIZE(*list, 0);
  82 }
  83
  84 static vector_DevMap PlaybackDevices;
  85 static vector_DevMap CaptureDevices;
  86
  87
  88 static HANDLE ThreadHdl;
  89 static DWORD ThreadID;
  90
  91 typedef struct {
  92     HANDLE FinishedEvt;
  93     HRESULT result;
  94 } ThreadRequest;
  95
  96 #define WM_USER_First       (WM_USER+0)
  97 #define WM_USER_OpenDevice  (WM_USER+0)
  98 #define WM_USER_ResetDevice (WM_USER+1)
  99 #define WM_USER_StartDevice (WM_USER+2)
 100 #define WM_USER_StopDevice  (WM_USER+3)
 101 #define WM_USER_CloseDevice (WM_USER+4)
 102 #define WM_USER_Enumerate   (WM_USER+5)
 103 #define WM_USER_Last        (WM_USER+5)
 104
 105 static inline void ReturnMsgResponse(ThreadRequest *req, HRESULT res)
 106 {
 107     req->result = res;
 108     SetEvent(req->FinishedEvt);
 109 }
 110
 111 static HRESULT WaitForResponse(ThreadRequest *req)
 112 {
 113     if(WaitForSingleObject(req->FinishedEvt, INFINITE) == WAIT_OBJECT_0)
 114         return req->result;
 115     ERR("Message response error: %lu\n", GetLastError());
 116     return E_FAIL;
 117 }
 118
 119
 120 static void get_device_name(IMMDevice *device, al_string *name)
 121 {
 122     IPropertyStore *ps;
 123     PROPVARIANT pvname;
 124     HRESULT hr;
 125
 126     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 127     if(FAILED(hr))
 128     {
 129         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 130         return;
 131     }
 132
 133     PropVariantInit(&pvname);
 134
 135     hr = IPropertyStore_GetValue(ps, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pvname);
 136     if(FAILED(hr))
 137         WARN("GetValue failed: 0x%08lx\n", hr);
 138     else
 139         al_string_copy_wcstr(name, pvname.pwszVal);
 140
 141     PropVariantClear(&pvname);
 142     IPropertyStore_Release(ps);
 143 }
 144
 145 static void add_device(IMMDevice *device, LPCWSTR devid, vector_DevMap *list)
 146 {
 147     DevMap entry;
 148
 149     AL_STRING_INIT(entry.name);
 150     entry.devid = strdupW(devid);
 151     get_device_name(device, &entry.name);
 152
 153     TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
 154     VECTOR_PUSH_BACK(*list, entry);
 155 }
 156
 157 static LPWSTR get_device_id(IMMDevice *device)
 158 {
 159     LPWSTR devid;
 160     HRESULT hr;
 161
 162     hr = IMMDevice_GetId(device, &devid);
 163     if(FAILED(hr))
 164     {
 165         ERR("Failed to get device id: %lx\n", hr);
 166         return NULL;
 167     }
 168
 169     return devid;
 170 }
 171
 172 static HRESULT probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, vector_DevMap *list)
 173 {
 174     IMMDeviceCollection *coll;
 175     IMMDevice *defdev = NULL;
 176     LPWSTR defdevid = NULL;
 177     HRESULT hr;
 178     UINT count;
 179     UINT i;
 180
 181     hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
 182     if(FAILED(hr))
 183     {
 184         ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
 185         return hr;
 186     }
 187
 188     count = 0;
 189     hr = IMMDeviceCollection_GetCount(coll, &count);
 190     if(SUCCEEDED(hr) && count > 0)
 191     {
 192         clear_devlist(list);
 193         if(!VECTOR_RESERVE(*list, count))
 194         {
 195             IMMDeviceCollection_Release(coll);
 196             return E_OUTOFMEMORY;
 197         }
 198
 199         hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
 200                                                          eMultimedia, &defdev);
 201     }
 202     if(SUCCEEDED(hr) && defdev != NULL)
 203     {
 204         defdevid = get_device_id(defdev);
 205         if(defdevid)
 206             add_device(defdev, defdevid, list);
 207     }
 208
 209     for(i = 0;i < count;++i)
 210     {
 211         IMMDevice *device;
 212         LPWSTR devid;
 213
 214         hr = IMMDeviceCollection_Item(coll, i, &device);
 215         if(FAILED(hr)) continue;
 216
 217         devid = get_device_id(device);
 218         if(devid)
 219         {
 220             if(wcscmp(devid, defdevid) != 0)
 221                 add_device(device, devid, list);
 222             CoTaskMemFree(devid);
 223         }
 224         IMMDevice_Release(device);
 225     }
 226
 227     if(defdev) IMMDevice_Release(defdev);
 228     if(defdevid) CoTaskMemFree(defdevid);
 229     IMMDeviceCollection_Release(coll);
 230
 231     return S_OK;
 232 }
 233
 234
 235 /* Proxy interface used by the message handler. */
 236 struct ALCmmdevProxyVtable;
 237
 238 typedef struct ALCmmdevProxy {
 239     const struct ALCmmdevProxyVtable *vtbl;
 240 } ALCmmdevProxy;
 241
 242 struct ALCmmdevProxyVtable {
 243     HRESULT (*const openProxy)(ALCmmdevProxy*);
 244     void (*const closeProxy)(ALCmmdevProxy*);
 245
 246     HRESULT (*const resetProxy)(ALCmmdevProxy*);
 247     HRESULT (*const startProxy)(ALCmmdevProxy*);
 248     void  (*const stopProxy)(ALCmmdevProxy*);
 249 };
 250
 251 #define DEFINE_ALCMMDEVPROXY_VTABLE(T)                                        \
 252 DECLARE_THUNK(T, ALCmmdevProxy, HRESULT, openProxy)                           \
 253 DECLARE_THUNK(T, ALCmmdevProxy, void, closeProxy)                             \
 254 DECLARE_THUNK(T, ALCmmdevProxy, HRESULT, resetProxy)                          \
 255 DECLARE_THUNK(T, ALCmmdevProxy, HRESULT, startProxy)                          \
 256 DECLARE_THUNK(T, ALCmmdevProxy, void, stopProxy)                              \
 257                                                                               \
 258 static const struct ALCmmdevProxyVtable T##_ALCmmdevProxy_vtable = {          \
 259     T##_ALCmmdevProxy_openProxy,                                              \
 260     T##_ALCmmdevProxy_closeProxy,                                             \
 261     T##_ALCmmdevProxy_resetProxy,                                             \
 262     T##_ALCmmdevProxy_startProxy,                                             \
 263     T##_ALCmmdevProxy_stopProxy,                                              \
 264 }
 265
 266 static void ALCmmdevProxy_Construct(ALCmmdevProxy* UNUSED(self)) { }
 267 static void ALCmmdevProxy_Destruct(ALCmmdevProxy* UNUSED(self)) { }
 268
 269 static DWORD CALLBACK ALCmmdevProxy_messageHandler(void *ptr)
 270 {
 271     ThreadRequest *req = ptr;
 272     IMMDeviceEnumerator *Enumerator;
 273     ALuint deviceCount = 0;
 274     ALCmmdevProxy *proxy;
 275     HRESULT hr, cohr;
 276     MSG msg;
 277
 278     TRACE("Starting message thread\n");
 279
 280     cohr = CoInitialize(NULL);
 281     if(FAILED(cohr))
 282     {
 283         WARN("Failed to initialize COM: 0x%08lx\n", cohr);
 284         ReturnMsgResponse(req, cohr);
 285         return 0;
 286     }
 287
 288     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 289     if(FAILED(hr))
 290     {
 291         WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
 292         CoUninitialize();
 293         ReturnMsgResponse(req, hr);
 294         return 0;
 295     }
 296     Enumerator = ptr;
 297     IMMDeviceEnumerator_Release(Enumerator);
 298     Enumerator = NULL;
 299
 300     CoUninitialize();
 301
 302     /* HACK: Force Windows to create a message queue for this thread before
 303      * returning success, otherwise PostThreadMessage may fail if it gets
 304      * called before GetMessage.
 305      */
 306     PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 307
 308     TRACE("Message thread initialization complete\n");
 309     ReturnMsgResponse(req, S_OK);
 310
 311     TRACE("Starting message loop\n");
 312     while(GetMessage(&msg, NULL, WM_USER_First, WM_USER_Last))
 313     {
 314         TRACE("Got message %u\n", msg.message);
 315         switch(msg.message)
 316         {
 317         case WM_USER_OpenDevice:
 318             req = (ThreadRequest*)msg.wParam;
 319             proxy = (ALCmmdevProxy*)msg.lParam;
 320
 321             hr = cohr = S_OK;
 322             if(++deviceCount == 1)
 323                 hr = cohr = CoInitialize(NULL);
 324             if(SUCCEEDED(hr))
 325                 hr = V0(proxy,openProxy)();
 326             if(FAILED(hr))
 327             {
 328                 if(--deviceCount == 0 && SUCCEEDED(cohr))
 329                     CoUninitialize();
 330             }
 331
 332             ReturnMsgResponse(req, hr);
 333             continue;
 334
 335         case WM_USER_ResetDevice:
 336             req = (ThreadRequest*)msg.wParam;
 337             proxy = (ALCmmdevProxy*)msg.lParam;
 338
 339             hr = V0(proxy,resetProxy)();
 340             ReturnMsgResponse(req, hr);
 341             continue;
 342
 343         case WM_USER_StartDevice:
 344             req = (ThreadRequest*)msg.wParam;
 345             proxy = (ALCmmdevProxy*)msg.lParam;
 346
 347             hr = V0(proxy,startProxy)();
 348             ReturnMsgResponse(req, hr);
 349             continue;
 350
 351         case WM_USER_StopDevice:
 352             req = (ThreadRequest*)msg.wParam;
 353             proxy = (ALCmmdevProxy*)msg.lParam;
 354
 355             V0(proxy,stopProxy)();
 356             ReturnMsgResponse(req, S_OK);
 357             continue;
 358
 359         case WM_USER_CloseDevice:
 360             req = (ThreadRequest*)msg.wParam;
 361             proxy = (ALCmmdevProxy*)msg.lParam;
 362
 363             V0(proxy,closeProxy)();
 364             if(--deviceCount == 0)
 365                 CoUninitialize();
 366
 367             ReturnMsgResponse(req, S_OK);
 368             continue;
 369
 370         case WM_USER_Enumerate:
 371             req = (ThreadRequest*)msg.wParam;
 372
 373             hr = cohr = S_OK;
 374             if(++deviceCount == 1)
 375                 hr = cohr = CoInitialize(NULL);
 376             if(SUCCEEDED(hr))
 377                 hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 378             if(SUCCEEDED(hr))
 379             {
 380                 Enumerator = ptr;
 381
 382                 if(msg.lParam == ALL_DEVICE_PROBE)
 383                     hr = probe_devices(Enumerator, eRender, &PlaybackDevices);
 384                 else if(msg.lParam == CAPTURE_DEVICE_PROBE)
 385                     hr = probe_devices(Enumerator, eCapture, &CaptureDevices);
 386
 387                 IMMDeviceEnumerator_Release(Enumerator);
 388                 Enumerator = NULL;
 389             }
 390
 391             if(--deviceCount == 0 && SUCCEEDED(cohr))
 392                 CoUninitialize();
 393
 394             ReturnMsgResponse(req, hr);
 395             continue;
 396
 397         default:
 398             ERR("Unexpected message: %u\n", msg.message);
 399             continue;
 400         }
 401     }
 402     TRACE("Message loop finished\n");
 403
 404     return 0;
 405 }
 406
 407
 408 typedef struct ALCmmdevPlayback {
 409     DERIVE_FROM_TYPE(ALCbackend);
 410     DERIVE_FROM_TYPE(ALCmmdevProxy);
 411
 412     WCHAR *devid;
 413
 414     IMMDevice *mmdev;
 415     IAudioClient *client;
 416     IAudioRenderClient *render;
 417     HANDLE NotifyEvent;
 418
 419     HANDLE MsgEvent;
 420
 421     volatile UINT32 Padding;
 422
 423     volatile int killNow;
 424     althrd_t thread;
 425 } ALCmmdevPlayback;
 426
 427 static int ALCmmdevPlayback_mixerProc(void *arg);
 428
 429 static void ALCmmdevPlayback_Construct(ALCmmdevPlayback *self, ALCdevice *device);
 430 static void ALCmmdevPlayback_Destruct(ALCmmdevPlayback *self);
 431 static ALCenum ALCmmdevPlayback_open(ALCmmdevPlayback *self, const ALCchar *name);
 432 static HRESULT ALCmmdevPlayback_openProxy(ALCmmdevPlayback *self);
 433 static void ALCmmdevPlayback_close(ALCmmdevPlayback *self);
 434 static void ALCmmdevPlayback_closeProxy(ALCmmdevPlayback *self);
 435 static ALCboolean ALCmmdevPlayback_reset(ALCmmdevPlayback *self);
 436 static HRESULT ALCmmdevPlayback_resetProxy(ALCmmdevPlayback *self);
 437 static ALCboolean ALCmmdevPlayback_start(ALCmmdevPlayback *self);
 438 static HRESULT ALCmmdevPlayback_startProxy(ALCmmdevPlayback *self);
 439 static void ALCmmdevPlayback_stop(ALCmmdevPlayback *self);
 440 static void ALCmmdevPlayback_stopProxy(ALCmmdevPlayback *self);
 441 static DECLARE_FORWARD2(ALCmmdevPlayback, ALCbackend, ALCenum, captureSamples, ALCvoid*, ALCuint)
 442 static DECLARE_FORWARD(ALCmmdevPlayback, ALCbackend, ALCuint, availableSamples)
 443 static ALint64 ALCmmdevPlayback_getLatency(ALCmmdevPlayback *self);
 444 static DECLARE_FORWARD(ALCmmdevPlayback, ALCbackend, void, lock)
 445 static DECLARE_FORWARD(ALCmmdevPlayback, ALCbackend, void, unlock)
 446 DECLARE_DEFAULT_ALLOCATORS(ALCmmdevPlayback)
 447
 448 DEFINE_ALCMMDEVPROXY_VTABLE(ALCmmdevPlayback);
 449 DEFINE_ALCBACKEND_VTABLE(ALCmmdevPlayback);
 450
 451
 452 static void ALCmmdevPlayback_Construct(ALCmmdevPlayback *self, ALCdevice *device)
 453 {
 454     SET_VTABLE2(ALCmmdevPlayback, ALCbackend, self);
 455     SET_VTABLE2(ALCmmdevPlayback, ALCmmdevProxy, self);
 456     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 457     ALCmmdevProxy_Construct(STATIC_CAST(ALCmmdevProxy, self));
 458
 459     self->devid = NULL;
 460
 461     self->mmdev = NULL;
 462     self->client = NULL;
 463     self->render = NULL;
 464     self->NotifyEvent = NULL;
 465
 466     self->MsgEvent = NULL;
 467
 468     self->Padding = 0;
 469
 470     self->killNow = 0;
 471 }
 472
 473 static void ALCmmdevPlayback_Destruct(ALCmmdevPlayback *self)
 474 {
 475     if(self->NotifyEvent != NULL)
 476         CloseHandle(self->NotifyEvent);
 477     self->NotifyEvent = NULL;
 478     if(self->MsgEvent != NULL)
 479         CloseHandle(self->MsgEvent);
 480     self->MsgEvent = NULL;
 481
 482     free(self->devid);
 483     self->devid = NULL;
 484
 485     ALCmmdevProxy_Destruct(STATIC_CAST(ALCmmdevProxy, self));
 486     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
 487 }
 488
 489
 490 FORCE_ALIGN static int ALCmmdevPlayback_mixerProc(void *arg)
 491 {
 492     ALCmmdevPlayback *self = arg;
 493     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 494     UINT32 buffer_len, written;
 495     ALuint update_size, len;
 496     BYTE *buffer;
 497     HRESULT hr;
 498
 499     hr = CoInitialize(NULL);
 500     if(FAILED(hr))
 501     {
 502         ERR("CoInitialize(NULL) failed: 0x%08lx\n", hr);
 503         ALCdevice_Lock(device);
 504         aluHandleDisconnect(device);
 505         ALCdevice_Unlock(device);
 506         return 1;
 507     }
 508
 509     SetRTPriority();
 510     althrd_setname(althrd_current(), MIXER_THREAD_NAME);
 511
 512     update_size = device->UpdateSize;
 513     buffer_len = update_size * device->NumUpdates;
 514     while(!self->killNow)
 515     {
 516         hr = IAudioClient_GetCurrentPadding(self->client, &written);
 517         if(FAILED(hr))
 518         {
 519             ERR("Failed to get padding: 0x%08lx\n", hr);
 520             ALCdevice_Lock(device);
 521             aluHandleDisconnect(device);
 522             ALCdevice_Unlock(device);
 523             break;
 524         }
 525         self->Padding = written;
 526
 527         len = buffer_len - written;
 528         if(len < update_size)
 529         {
 530             DWORD res;
 531             res = WaitForSingleObjectEx(self->NotifyEvent, 2000, FALSE);
 532             if(res != WAIT_OBJECT_0)
 533                 ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
 534             continue;
 535         }
 536         len -= len%update_size;
 537
 538         hr = IAudioRenderClient_GetBuffer(self->render, len, &buffer);
 539         if(SUCCEEDED(hr))
 540         {
 541             ALCdevice_Lock(device);
 542             aluMixData(device, buffer, len);
 543             self->Padding = written + len;
 544             ALCdevice_Unlock(device);
 545             hr = IAudioRenderClient_ReleaseBuffer(self->render, len, 0);
 546         }
 547         if(FAILED(hr))
 548         {
 549             ERR("Failed to buffer data: 0x%08lx\n", hr);
 550             ALCdevice_Lock(device);
 551             aluHandleDisconnect(device);
 552             ALCdevice_Unlock(device);
 553             break;
 554         }
 555     }
 556     self->Padding = 0;
 557
 558     CoUninitialize();
 559     return 0;
 560 }
 561
 562
 563 static ALCboolean MakeExtensible(WAVEFORMATEXTENSIBLE *out, const WAVEFORMATEX *in)
 564 {
 565     memset(out, 0, sizeof(*out));
 566     if(in->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 567         *out = *(const WAVEFORMATEXTENSIBLE*)in;
 568     else if(in->wFormatTag == WAVE_FORMAT_PCM)
 569     {
 570         out->Format = *in;
 571         out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 572         out->Format.cbSize = sizeof(*out) - sizeof(*in);
 573         if(out->Format.nChannels == 1)
 574             out->dwChannelMask = MONO;
 575         else if(out->Format.nChannels == 2)
 576             out->dwChannelMask = STEREO;
 577         else
 578             ERR("Unhandled PCM channel count: %d\n", out->Format.nChannels);
 579         out->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 580     }
 581     else if(in->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 582     {
 583         out->Format = *in;
 584         out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 585         out->Format.cbSize = sizeof(*out) - sizeof(*in);
 586         if(out->Format.nChannels == 1)
 587             out->dwChannelMask = MONO;
 588         else if(out->Format.nChannels == 2)
 589             out->dwChannelMask = STEREO;
 590         else
 591             ERR("Unhandled IEEE float channel count: %d\n", out->Format.nChannels);
 592         out->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 593     }
 594     else
 595     {
 596         ERR("Unhandled format tag: 0x%04x\n", in->wFormatTag);
 597         return ALC_FALSE;
 598     }
 599     return ALC_TRUE;
 600 }
 601
 602
 603 static ALCenum ALCmmdevPlayback_open(ALCmmdevPlayback *self, const ALCchar *deviceName)
 604 {
 605     HRESULT hr = S_OK;
 606
 607     self->NotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 608     self->MsgEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 609     if(self->NotifyEvent == NULL || self->MsgEvent == NULL)
 610     {
 611         ERR("Failed to create message events: %lu\n", GetLastError());
 612         hr = E_FAIL;
 613     }
 614
 615     if(SUCCEEDED(hr))
 616     {
 617         if(deviceName)
 618         {
 619             const DevMap *iter, *end;
 620
 621             if(VECTOR_SIZE(PlaybackDevices) == 0)
 622             {
 623                 ThreadRequest req = { self->MsgEvent, 0 };
 624                 if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, ALL_DEVICE_PROBE))
 625                     (void)WaitForResponse(&req);
 626             }
 627
 628             hr = E_FAIL;
 629             iter = VECTOR_ITER_BEGIN(PlaybackDevices);
 630             end = VECTOR_ITER_END(PlaybackDevices);
 631             for(;iter != end;iter++)
 632             {
 633                 if(al_string_cmp_cstr(iter->name, deviceName) == 0)
 634                 {
 635                     self->devid = strdupW(iter->devid);
 636                     hr = S_OK;
 637                     break;
 638                 }
 639             }
 640             if(FAILED(hr))
 641                 WARN("Failed to find device name matching \"%s\"\n", deviceName);
 642         }
 643     }
 644
 645     if(SUCCEEDED(hr))
 646     {
 647         ThreadRequest req = { self->MsgEvent, 0 };
 648
 649         hr = E_FAIL;
 650         if(PostThreadMessage(ThreadID, WM_USER_OpenDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
 651             hr = WaitForResponse(&req);
 652         else
 653             ERR("Failed to post thread message: %lu\n", GetLastError());
 654     }
 655
 656     if(FAILED(hr))
 657     {
 658         if(self->NotifyEvent != NULL)
 659             CloseHandle(self->NotifyEvent);
 660         self->NotifyEvent = NULL;
 661         if(self->MsgEvent != NULL)
 662             CloseHandle(self->MsgEvent);
 663         self->MsgEvent = NULL;
 664
 665         free(self->devid);
 666         self->devid = NULL;
 667
 668         ERR("Device init failed: 0x%08lx\n", hr);
 669         return ALC_INVALID_VALUE;
 670     }
 671
 672     return ALC_NO_ERROR;
 673 }
 674
 675 static HRESULT ALCmmdevPlayback_openProxy(ALCmmdevPlayback *self)
 676 {
 677     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 678     void *ptr;
 679     HRESULT hr;
 680
 681     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 682     if(SUCCEEDED(hr))
 683     {
 684         IMMDeviceEnumerator *Enumerator = ptr;
 685         if(!self->devid)
 686             hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &self->mmdev);
 687         else
 688             hr = IMMDeviceEnumerator_GetDevice(Enumerator, self->devid, &self->mmdev);
 689         IMMDeviceEnumerator_Release(Enumerator);
 690         Enumerator = NULL;
 691     }
 692     if(SUCCEEDED(hr))
 693         hr = IMMDevice_Activate(self->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
 694     if(SUCCEEDED(hr))
 695     {
 696         self->client = ptr;
 697         get_device_name(self->mmdev, &device->DeviceName);
 698     }
 699
 700     if(FAILED(hr))
 701     {
 702         if(self->mmdev)
 703             IMMDevice_Release(self->mmdev);
 704         self->mmdev = NULL;
 705     }
 706
 707     return hr;
 708 }
 709
 710
 711 static void ALCmmdevPlayback_close(ALCmmdevPlayback *self)
 712 {
 713     ThreadRequest req = { self->MsgEvent, 0 };
 714
 715     if(PostThreadMessage(ThreadID, WM_USER_CloseDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
 716         (void)WaitForResponse(&req);
 717
 718     CloseHandle(self->MsgEvent);
 719     self->MsgEvent = NULL;
 720
 721     CloseHandle(self->NotifyEvent);
 722     self->NotifyEvent = NULL;
 723
 724     free(self->devid);
 725     self->devid = NULL;
 726 }
 727
 728 static void ALCmmdevPlayback_closeProxy(ALCmmdevPlayback *self)
 729 {
 730     if(self->client)
 731         IAudioClient_Release(self->client);
 732     self->client = NULL;
 733
 734     if(self->mmdev)
 735         IMMDevice_Release(self->mmdev);
 736     self->mmdev = NULL;
 737 }
 738
 739
 740 static ALCboolean ALCmmdevPlayback_reset(ALCmmdevPlayback *self)
 741 {
 742     ThreadRequest req = { self->MsgEvent, 0 };
 743     HRESULT hr = E_FAIL;
 744
 745     if(PostThreadMessage(ThreadID, WM_USER_ResetDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
 746         hr = WaitForResponse(&req);
 747
 748     return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
 749 }
 750
 751 static HRESULT ALCmmdevPlayback_resetProxy(ALCmmdevPlayback *self)
 752 {
 753     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 754     WAVEFORMATEXTENSIBLE OutputType;
 755     WAVEFORMATEX *wfx = NULL;
 756     REFERENCE_TIME min_per, buf_time;
 757     UINT32 buffer_len, min_len;
 758     void *ptr = NULL;
 759     HRESULT hr;
 760
 761     if(self->client)
 762         IAudioClient_Release(self->client);
 763     self->client = NULL;
 764
 765     hr = IMMDevice_Activate(self->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
 766     if(FAILED(hr))
 767     {
 768         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
 769         return hr;
 770     }
 771     self->client = ptr;
 772
 773     hr = IAudioClient_GetMixFormat(self->client, &wfx);
 774     if(FAILED(hr))
 775     {
 776         ERR("Failed to get mix format: 0x%08lx\n", hr);
 777         return hr;
 778     }
 779
 780     if(!MakeExtensible(&OutputType, wfx))
 781     {
 782         CoTaskMemFree(wfx);
 783         return E_FAIL;
 784     }
 785     CoTaskMemFree(wfx);
 786     wfx = NULL;
 787
 788     buf_time = ((REFERENCE_TIME)device->UpdateSize*device->NumUpdates*10000000 +
 789                                 device->Frequency-1) / device->Frequency;
 790
 791     if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
 792         device->Frequency = OutputType.Format.nSamplesPerSec;
 793     if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
 794     {
 795         if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
 796             device->FmtChans = DevFmtMono;
 797         else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
 798             device->FmtChans = DevFmtStereo;
 799         else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
 800             device->FmtChans = DevFmtQuad;
 801         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
 802             device->FmtChans = DevFmtX51;
 803         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1REAR)
 804             device->FmtChans = DevFmtX51Rear;
 805         else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
 806             device->FmtChans = DevFmtX61;
 807         else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
 808             device->FmtChans = DevFmtX71;
 809         else
 810             ERR("Unhandled channel config: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
 811     }
 812
 813     switch(device->FmtChans)
 814     {
 815         case DevFmtMono:
 816             OutputType.Format.nChannels = 1;
 817             OutputType.dwChannelMask = MONO;
 818             break;
 819         case DevFmtStereo:
 820             OutputType.Format.nChannels = 2;
 821             OutputType.dwChannelMask = STEREO;
 822             break;
 823         case DevFmtQuad:
 824             OutputType.Format.nChannels = 4;
 825             OutputType.dwChannelMask = QUAD;
 826             break;
 827         case DevFmtX51:
 828             OutputType.Format.nChannels = 6;
 829             OutputType.dwChannelMask = X5DOT1;
 830             break;
 831         case DevFmtX51Rear:
 832             OutputType.Format.nChannels = 6;
 833             OutputType.dwChannelMask = X5DOT1REAR;
 834             break;
 835         case DevFmtX61:
 836             OutputType.Format.nChannels = 7;
 837             OutputType.dwChannelMask = X6DOT1;
 838             break;
 839         case DevFmtX71:
 840             OutputType.Format.nChannels = 8;
 841             OutputType.dwChannelMask = X7DOT1;
 842             break;
 843     }
 844     switch(device->FmtType)
 845     {
 846         case DevFmtByte:
 847             device->FmtType = DevFmtUByte;
 848             /* fall-through */
 849         case DevFmtUByte:
 850             OutputType.Format.wBitsPerSample = 8;
 851             OutputType.Samples.wValidBitsPerSample = 8;
 852             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 853             break;
 854         case DevFmtUShort:
 855             device->FmtType = DevFmtShort;
 856             /* fall-through */
 857         case DevFmtShort:
 858             OutputType.Format.wBitsPerSample = 16;
 859             OutputType.Samples.wValidBitsPerSample = 16;
 860             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 861             break;
 862         case DevFmtUInt:
 863             device->FmtType = DevFmtInt;
 864             /* fall-through */
 865         case DevFmtInt:
 866             OutputType.Format.wBitsPerSample = 32;
 867             OutputType.Samples.wValidBitsPerSample = 32;
 868             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 869             break;
 870         case DevFmtFloat:
 871             OutputType.Format.wBitsPerSample = 32;
 872             OutputType.Samples.wValidBitsPerSample = 32;
 873             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 874             break;
 875     }
 876     OutputType.Format.nSamplesPerSec = device->Frequency;
 877
 878     OutputType.Format.nBlockAlign = OutputType.Format.nChannels *
 879                                     OutputType.Format.wBitsPerSample / 8;
 880     OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
 881                                         OutputType.Format.nBlockAlign;
 882
 883     hr = IAudioClient_IsFormatSupported(self->client, AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
 884     if(FAILED(hr))
 885     {
 886         ERR("Failed to check format support: 0x%08lx\n", hr);
 887         hr = IAudioClient_GetMixFormat(self->client, &wfx);
 888     }
 889     if(FAILED(hr))
 890     {
 891         ERR("Failed to find a supported format: 0x%08lx\n", hr);
 892         return hr;
 893     }
 894
 895     if(wfx != NULL)
 896     {
 897         if(!MakeExtensible(&OutputType, wfx))
 898         {
 899             CoTaskMemFree(wfx);
 900             return E_FAIL;
 901         }
 902         CoTaskMemFree(wfx);
 903         wfx = NULL;
 904
 905         device->Frequency = OutputType.Format.nSamplesPerSec;
 906         if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
 907             device->FmtChans = DevFmtMono;
 908         else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
 909             device->FmtChans = DevFmtStereo;
 910         else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
 911             device->FmtChans = DevFmtQuad;
 912         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
 913             device->FmtChans = DevFmtX51;
 914         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1REAR)
 915             device->FmtChans = DevFmtX51Rear;
 916         else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
 917             device->FmtChans = DevFmtX61;
 918         else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
 919             device->FmtChans = DevFmtX71;
 920         else
 921         {
 922             ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
 923             device->FmtChans = DevFmtStereo;
 924             OutputType.Format.nChannels = 2;
 925             OutputType.dwChannelMask = STEREO;
 926         }
 927
 928         if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 929         {
 930             if(OutputType.Format.wBitsPerSample == 8)
 931                 device->FmtType = DevFmtUByte;
 932             else if(OutputType.Format.wBitsPerSample == 16)
 933                 device->FmtType = DevFmtShort;
 934             else if(OutputType.Format.wBitsPerSample == 32)
 935                 device->FmtType = DevFmtInt;
 936             else
 937             {
 938                 device->FmtType = DevFmtShort;
 939                 OutputType.Format.wBitsPerSample = 16;
 940             }
 941         }
 942         else if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
 943         {
 944             device->FmtType = DevFmtFloat;
 945             OutputType.Format.wBitsPerSample = 32;
 946         }
 947         else
 948         {
 949             ERR("Unhandled format sub-type\n");
 950             device->FmtType = DevFmtShort;
 951             OutputType.Format.wBitsPerSample = 16;
 952             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 953         }
 954         OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
 955     }
 956
 957     SetDefaultWFXChannelOrder(device);
 958
 959     hr = IAudioClient_Initialize(self->client, AUDCLNT_SHAREMODE_SHARED,
 960                                  AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
 961                                  buf_time, 0, &OutputType.Format, NULL);
 962     if(FAILED(hr))
 963     {
 964         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
 965         return hr;
 966     }
 967
 968     hr = IAudioClient_GetDevicePeriod(self->client, &min_per, NULL);
 969     if(SUCCEEDED(hr))
 970     {
 971         min_len = (UINT32)((min_per*device->Frequency + 10000000-1) / 10000000);
 972         /* Find the nearest multiple of the period size to the update size */
 973         if(min_len < device->UpdateSize)
 974             min_len *= (device->UpdateSize + min_len/2)/min_len;
 975         hr = IAudioClient_GetBufferSize(self->client, &buffer_len);
 976     }
 977     if(FAILED(hr))
 978     {
 979         ERR("Failed to get audio buffer info: 0x%08lx\n", hr);
 980         return hr;
 981     }
 982
 983     device->UpdateSize = min_len;
 984     device->NumUpdates = buffer_len / device->UpdateSize;
 985     if(device->NumUpdates <= 1)
 986     {
 987         ERR("Audio client returned buffer_len < period*2; expect break up\n");
 988         device->NumUpdates = 2;
 989         device->UpdateSize = buffer_len / device->NumUpdates;
 990     }
 991
 992     hr = IAudioClient_SetEventHandle(self->client, self->NotifyEvent);
 993     if(FAILED(hr))
 994     {
 995         ERR("Failed to set event handle: 0x%08lx\n", hr);
 996         return hr;
 997     }
 998
 999     return hr;
1000 }
1001
1002
1003 static ALCboolean ALCmmdevPlayback_start(ALCmmdevPlayback *self)
1004 {
1005     ThreadRequest req = { self->MsgEvent, 0 };
1006     HRESULT hr = E_FAIL;
1007
1008     if(PostThreadMessage(ThreadID, WM_USER_StartDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1009         hr = WaitForResponse(&req);
1010
1011     return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
1012 }
1013
1014 static HRESULT ALCmmdevPlayback_startProxy(ALCmmdevPlayback *self)
1015 {
1016     HRESULT hr;
1017     void *ptr;
1018
1019     ResetEvent(self->NotifyEvent);
1020     hr = IAudioClient_Start(self->client);
1021     if(FAILED(hr))
1022         ERR("Failed to start audio client: 0x%08lx\n", hr);
1023
1024     if(SUCCEEDED(hr))
1025         hr = IAudioClient_GetService(self->client, &IID_IAudioRenderClient, &ptr);
1026     if(SUCCEEDED(hr))
1027     {
1028         self->render = ptr;
1029         self->killNow = 0;
1030         if(althrd_create(&self->thread, ALCmmdevPlayback_mixerProc, self) != althrd_success)
1031         {
1032             if(self->render)
1033                 IAudioRenderClient_Release(self->render);
1034             self->render = NULL;
1035             IAudioClient_Stop(self->client);
1036             ERR("Failed to start thread\n");
1037             hr = E_FAIL;
1038         }
1039     }
1040
1041     return hr;
1042 }
1043
1044
1045 static void ALCmmdevPlayback_stop(ALCmmdevPlayback *self)
1046 {
1047     ThreadRequest req = { self->MsgEvent, 0 };
1048     if(PostThreadMessage(ThreadID, WM_USER_StopDevice, (WPARAM)&req, (LPARAM)STATIC_CAST(ALCmmdevProxy, self)))
1049         (void)WaitForResponse(&req);
1050 }
1051
1052 static void ALCmmdevPlayback_stopProxy(ALCmmdevPlayback *self)
1053 {
1054     int res;
1055
1056     if(!self->render)
1057         return;
1058
1059     self->killNow = 1;
1060     althrd_join(self->thread, &res);
1061
1062     IAudioRenderClient_Release(self->render);
1063     self->render = NULL;
1064     IAudioClient_Stop(self->client);
1065 }
1066
1067
1068 static ALint64 ALCmmdevPlayback_getLatency(ALCmmdevPlayback *self)
1069 {
1070     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
1071     return (ALint64)self->Padding * 1000000000 / device->Frequency;
1072 }
1073
1074
1075 static inline void AppendAllDevicesList2(const DevMap *entry)
1076 { AppendAllDevicesList(al_string_get_cstr(entry->name)); }
1077 static inline void AppendCaptureDeviceList2(const DevMap *entry)
1078 { AppendCaptureDeviceList(al_string_get_cstr(entry->name)); }
1079
1080 typedef struct ALCmmdevBackendFactory {
1081     DERIVE_FROM_TYPE(ALCbackendFactory);
1082 } ALCmmdevBackendFactory;
1083 #define ALCMMDEVBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCmmdevBackendFactory, ALCbackendFactory) } }
1084
1085 static ALCboolean ALCmmdevBackendFactory_init(ALCmmdevBackendFactory *self);
1086 static void ALCmmdevBackendFactory_deinit(ALCmmdevBackendFactory *self);
1087 static ALCboolean ALCmmdevBackendFactory_querySupport(ALCmmdevBackendFactory *self, ALCbackend_Type type);
1088 static void ALCmmdevBackendFactory_probe(ALCmmdevBackendFactory *self, enum DevProbe type);
1089 static ALCbackend* ALCmmdevBackendFactory_createBackend(ALCmmdevBackendFactory *self, ALCdevice *device, ALCbackend_Type type);
1090
1091 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCmmdevBackendFactory);
1092
1093
1094 static BOOL MMDevApiLoad(void)
1095 {
1096     static HRESULT InitResult;
1097     if(!ThreadHdl)
1098     {
1099         ThreadRequest req;
1100         InitResult = E_FAIL;
1101
1102         req.FinishedEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
1103         if(req.FinishedEvt == NULL)
1104             ERR("Failed to create event: %lu\n", GetLastError());
1105         else
1106         {
1107             ThreadHdl = CreateThread(NULL, 0, ALCmmdevProxy_messageHandler, &req, 0, &ThreadID);
1108             if(ThreadHdl != NULL)
1109                 InitResult = WaitForResponse(&req);
1110             CloseHandle(req.FinishedEvt);
1111         }
1112     }
1113     return SUCCEEDED(InitResult);
1114 }
1115
1116 static ALCboolean ALCmmdevBackendFactory_init(ALCmmdevBackendFactory* UNUSED(self))
1117 {
1118     VECTOR_INIT(PlaybackDevices);
1119     VECTOR_INIT(CaptureDevices);
1120
1121     if(!MMDevApiLoad())
1122         return ALC_FALSE;
1123     return ALC_TRUE;
1124 }
1125
1126 static void ALCmmdevBackendFactory_deinit(ALCmmdevBackendFactory* UNUSED(self))
1127 {
1128     clear_devlist(&PlaybackDevices);
1129     VECTOR_DEINIT(PlaybackDevices);
1130
1131     clear_devlist(&CaptureDevices);
1132     VECTOR_DEINIT(CaptureDevices);
1133
1134     if(ThreadHdl)
1135     {
1136         TRACE("Sending WM_QUIT to Thread %04lx\n", ThreadID);
1137         PostThreadMessage(ThreadID, WM_QUIT, 0, 0);
1138         CloseHandle(ThreadHdl);
1139         ThreadHdl = NULL;
1140     }
1141 }
1142
1143 static ALCboolean ALCmmdevBackendFactory_querySupport(ALCmmdevBackendFactory* UNUSED(self), ALCbackend_Type type)
1144 {
1145     if(type == ALCbackend_Playback)
1146         return ALC_TRUE;
1147     return ALC_FALSE;
1148 }
1149
1150 static void ALCmmdevBackendFactory_probe(ALCmmdevBackendFactory* UNUSED(self), enum DevProbe type)
1151 {
1152     ThreadRequest req = { NULL, 0 };
1153
1154     req.FinishedEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
1155     if(req.FinishedEvt == NULL)
1156         ERR("Failed to create event: %lu\n", GetLastError());
1157     else
1158     {
1159         HRESULT hr = E_FAIL;
1160         if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, type))
1161             hr = WaitForResponse(&req);
1162         if(SUCCEEDED(hr)) switch(type)
1163         {
1164         case ALL_DEVICE_PROBE:
1165             VECTOR_FOR_EACH(const DevMap, PlaybackDevices, AppendAllDevicesList2);
1166             break;
1167
1168         case CAPTURE_DEVICE_PROBE:
1169             VECTOR_FOR_EACH(const DevMap, CaptureDevices, AppendCaptureDeviceList2);
1170             break;
1171         }
1172         CloseHandle(req.FinishedEvt);
1173         req.FinishedEvt = NULL;
1174     }
1175 }
1176
1177 static ALCbackend* ALCmmdevBackendFactory_createBackend(ALCmmdevBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
1178 {
1179     if(type == ALCbackend_Playback)
1180     {
1181         ALCmmdevPlayback *backend;
1182
1183         backend = ALCmmdevPlayback_New(sizeof(*backend));
1184         if(!backend) return NULL;
1185         memset(backend, 0, sizeof(*backend));
1186
1187         ALCmmdevPlayback_Construct(backend, device);
1188
1189         return STATIC_CAST(ALCbackend, backend);
1190     }
1191
1192     return NULL;
1193 }
1194
1195
1196 ALCbackendFactory *ALCmmdevBackendFactory_getFactory(void)
1197 {
1198     static ALCmmdevBackendFactory factory = ALCMMDEVBACKENDFACTORY_INITIALIZER;
1199     return STATIC_CAST(ALCbackendFactory, &factory);
1200 }