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