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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, 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 <mmreg.h>
  32 #include <propsys.h>
  33 #include <propkey.h>
  34 #include <devpkey.h>
  35 #ifndef _WAVEFORMATEXTENSIBLE_
  36 #include <ks.h>
  37 #include <ksmedia.h>
  38 #endif
  39
  40 #include "alMain.h"
  41 #include "AL/al.h"
  42 #include "AL/alc.h"
  43
  44
  45 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  46 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  47
  48 #define MONO SPEAKER_FRONT_CENTER
  49 #define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
  50 #define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  51 #define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  52 #define X5DOT1SIDE (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  53 #define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
  54 #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)
  55
  56
  57 typedef struct {
  58     GUID guid;
  59     IMMDevice *mmdev;
  60     IAudioClient *client;
  61     HANDLE hNotifyEvent;
  62
  63     HANDLE MsgEvent;
  64
  65     volatile int killNow;
  66     ALvoid *thread;
  67 } MMDevApiData;
  68
  69
  70 typedef struct {
  71     ALCchar *name;
  72     GUID guid;
  73 } DevMap;
  74
  75 static const ALCchar mmDevice[] = "WASAPI Default";
  76 static DevMap *PlaybackDeviceList;
  77 static ALuint NumPlaybackDevices;
  78 static DevMap *CaptureDeviceList;
  79 static ALuint NumCaptureDevices;
  80
  81
  82 static HANDLE ThreadHdl;
  83 static DWORD ThreadID;
  84
  85 typedef struct {
  86     HANDLE FinishedEvt;
  87     HRESULT result;
  88 } ThreadRequest;
  89
  90 #define WM_USER_OpenDevice  (WM_USER+0)
  91 #define WM_USER_ResetDevice (WM_USER+1)
  92 #define WM_USER_StopDevice  (WM_USER+2)
  93 #define WM_USER_CloseDevice (WM_USER+3)
  94 #define WM_USER_Enumerate   (WM_USER+4)
  95
  96 static HRESULT WaitForResponse(ThreadRequest *req)
  97 {
  98     if(WaitForSingleObject(req->FinishedEvt, INFINITE) == WAIT_OBJECT_0)
  99         return req->result;
 100     ERR("Message response error: %lu\n", GetLastError());
 101     return E_FAIL;
 102 }
 103
 104
 105 static HRESULT get_mmdevice_by_guid(IMMDeviceEnumerator *devenum, EDataFlow flowdir, const GUID *guid, IMMDevice **out)
 106 {
 107     IMMDeviceCollection *coll;
 108     DWORD count, i;
 109     HRESULT hr;
 110
 111     hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
 112     if(FAILED(hr))
 113     {
 114         ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
 115         return hr;
 116     }
 117
 118     count = 0;
 119     IMMDeviceCollection_GetCount(coll, &count);
 120     for(i = 0;i < count;++i)
 121     {
 122         IMMDevice *device;
 123         IPropertyStore *ps;
 124         PROPVARIANT pv;
 125         GUID devid;
 126
 127         if(FAILED(IMMDeviceCollection_Item(coll, i, &device)))
 128             continue;
 129
 130         hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 131         if(FAILED(hr))
 132         {
 133             WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 134             continue;
 135         }
 136
 137         PropVariantInit(&pv);
 138
 139         hr = IPropertyStore_GetValue(ps, &PKEY_AudioEndpoint_GUID, &pv);
 140         if(FAILED(hr))
 141         {
 142             PropVariantClear(&pv);
 143             IPropertyStore_Release(ps);
 144             WARN("GetValue failed: 0x%08lx\n", hr);
 145             continue;
 146         }
 147         CLSIDFromString(pv.pwszVal, &devid);
 148
 149         PropVariantClear(&pv);
 150         IPropertyStore_Release(ps);
 151
 152         if(IsEqualGUID(&devid, guid))
 153         {
 154             *out = device;
 155             break;
 156         }
 157
 158         IMMDevice_Release(device);
 159     }
 160     hr = ((i==count) ? E_FAIL : S_OK);
 161
 162     IMMDeviceCollection_Release(coll);
 163     return hr;
 164 }
 165
 166
 167 static void add_device(IMMDevice *device, DevMap *devmap)
 168 {
 169     IPropertyStore *ps;
 170     PROPVARIANT pvguid;
 171     PROPVARIANT pvname;
 172     HRESULT hr;
 173     int len;
 174
 175     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 176     if(FAILED(hr))
 177     {
 178         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 179         return;
 180     }
 181
 182     PropVariantInit(&pvguid);
 183     PropVariantInit(&pvname);
 184
 185     hr = IPropertyStore_GetValue(ps, &PKEY_AudioEndpoint_GUID, &pvguid);
 186     if(FAILED(hr))
 187         WARN("GetValue failed: 0x%08lx\n", hr);
 188     else
 189     {
 190         hr = IPropertyStore_GetValue(ps, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pvname);
 191         if(FAILED(hr))
 192             WARN("GetValue failed: 0x%08lx\n", hr);
 193     }
 194     if(SUCCEEDED(hr))
 195     {
 196         CLSIDFromString(pvguid.pwszVal, &devmap->guid);
 197         if((len=WideCharToMultiByte(CP_ACP, 0, pvname.pwszVal, -1, NULL, 0, NULL, NULL)) > 0)
 198         {
 199             devmap->name = calloc(1, len);
 200             WideCharToMultiByte(CP_ACP, 0, pvname.pwszVal, -1, devmap->name, len, NULL, NULL);
 201         }
 202     }
 203
 204     PropVariantClear(&pvname);
 205     PropVariantClear(&pvguid);
 206     IPropertyStore_Release(ps);
 207 }
 208
 209 static DevMap *ProbeDevices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, ALuint *numdevs)
 210 {
 211     IMMDeviceCollection *coll;
 212     IMMDevice *defdev = NULL;
 213     DevMap *devlist;
 214     DWORD count;
 215     HRESULT hr;
 216     DWORD idx;
 217     DWORD i;
 218
 219     hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
 220     if(FAILED(hr))
 221     {
 222         ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
 223         return NULL;
 224     }
 225
 226     idx = count = 0;
 227     hr = IMMDeviceCollection_GetCount(coll, &count);
 228     if(SUCCEEDED(hr) && count > 0)
 229     {
 230         devlist = calloc(count, sizeof(*devlist));
 231         if(!devlist)
 232         {
 233             IMMDeviceCollection_Release(coll);
 234             return NULL;
 235         }
 236
 237         hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
 238                                                          eMultimedia, &defdev);
 239     }
 240     if(SUCCEEDED(hr) && defdev != NULL)
 241         add_device(defdev, &devlist[idx++]);
 242
 243     for(i = 0;i < count && idx < count;++i)
 244     {
 245         IMMDevice *device;
 246
 247         if(FAILED(IMMDeviceCollection_Item(coll, i, &device)))
 248             continue;
 249
 250         if(device != defdev)
 251             add_device(device, &devlist[idx++]);
 252
 253         IMMDevice_Release(device);
 254     }
 255
 256     if(defdev) IMMDevice_Release(defdev);
 257     IMMDeviceCollection_Release(coll);
 258
 259     *numdevs = idx;
 260     return devlist;
 261 }
 262
 263
 264 static ALuint MMDevApiProc(ALvoid *ptr)
 265 {
 266     ALCdevice *device = ptr;
 267     MMDevApiData *data = device->ExtraData;
 268     union {
 269         IAudioRenderClient *iface;
 270         void *ptr;
 271     } render;
 272     UINT32 written, len;
 273     BYTE *buffer;
 274     HRESULT hr;
 275
 276     hr = CoInitialize(NULL);
 277     if(FAILED(hr))
 278     {
 279         ERR("CoInitialize(NULL) failed: 0x%08lx\n", hr);
 280         aluHandleDisconnect(device);
 281         return 0;
 282     }
 283
 284     hr = IAudioClient_GetService(data->client, &IID_IAudioRenderClient, &render.ptr);
 285     if(FAILED(hr))
 286     {
 287         ERR("Failed to get AudioRenderClient service: 0x%08lx\n", hr);
 288         aluHandleDisconnect(device);
 289         return 0;
 290     }
 291
 292     SetRTPriority();
 293
 294     while(!data->killNow)
 295     {
 296         hr = IAudioClient_GetCurrentPadding(data->client, &written);
 297         if(FAILED(hr))
 298         {
 299             ERR("Failed to get padding: 0x%08lx\n", hr);
 300             aluHandleDisconnect(device);
 301             break;
 302         }
 303
 304         len = device->UpdateSize*device->NumUpdates - written;
 305         if(len < device->UpdateSize)
 306         {
 307             DWORD res;
 308             res = WaitForSingleObjectEx(data->hNotifyEvent, 2000, FALSE);
 309             if(res != WAIT_OBJECT_0)
 310                 ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
 311             continue;
 312         }
 313         len -= len%device->UpdateSize;
 314
 315         hr = IAudioRenderClient_GetBuffer(render.iface, len, &buffer);
 316         if(SUCCEEDED(hr))
 317         {
 318             aluMixData(device, buffer, len);
 319             hr = IAudioRenderClient_ReleaseBuffer(render.iface, len, 0);
 320         }
 321         if(FAILED(hr))
 322         {
 323             ERR("Failed to buffer data: 0x%08lx\n", hr);
 324             aluHandleDisconnect(device);
 325             break;
 326         }
 327     }
 328
 329     IAudioRenderClient_Release(render.iface);
 330
 331     CoUninitialize();
 332     return 0;
 333 }
 334
 335
 336 static ALCboolean MakeExtensible(WAVEFORMATEXTENSIBLE *out, const WAVEFORMATEX *in)
 337 {
 338     memset(out, 0, sizeof(*out));
 339     if(in->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 340         *out = *(WAVEFORMATEXTENSIBLE*)in;
 341     else if(in->wFormatTag == WAVE_FORMAT_PCM)
 342     {
 343         out->Format = *in;
 344         out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 345         out->Format.cbSize = sizeof(*out) - sizeof(*in);
 346         if(out->Format.nChannels == 1)
 347             out->dwChannelMask = MONO;
 348         else if(out->Format.nChannels == 2)
 349             out->dwChannelMask = STEREO;
 350         else
 351             ERR("Unhandled PCM channel count: %d\n", out->Format.nChannels);
 352         out->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 353     }
 354     else if(in->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 355     {
 356         out->Format = *in;
 357         out->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 358         out->Format.cbSize = sizeof(*out) - sizeof(*in);
 359         if(out->Format.nChannels == 1)
 360             out->dwChannelMask = MONO;
 361         else if(out->Format.nChannels == 2)
 362             out->dwChannelMask = STEREO;
 363         else
 364             ERR("Unhandled IEEE float channel count: %d\n", out->Format.nChannels);
 365         out->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 366     }
 367     else
 368     {
 369         ERR("Unhandled format tag: 0x%04x\n", in->wFormatTag);
 370         return ALC_FALSE;
 371     }
 372     return ALC_TRUE;
 373 }
 374
 375 static HRESULT DoReset(ALCdevice *device)
 376 {
 377     MMDevApiData *data = device->ExtraData;
 378     WAVEFORMATEXTENSIBLE OutputType;
 379     WAVEFORMATEX *wfx = NULL;
 380     REFERENCE_TIME min_per, buf_time;
 381     UINT32 buffer_len, min_len;
 382     HRESULT hr;
 383
 384     hr = IAudioClient_GetMixFormat(data->client, &wfx);
 385     if(FAILED(hr))
 386     {
 387         ERR("Failed to get mix format: 0x%08lx\n", hr);
 388         return hr;
 389     }
 390
 391     if(!MakeExtensible(&OutputType, wfx))
 392     {
 393         CoTaskMemFree(wfx);
 394         return E_FAIL;
 395     }
 396     CoTaskMemFree(wfx);
 397     wfx = NULL;
 398
 399     buf_time = ((REFERENCE_TIME)device->UpdateSize*device->NumUpdates*10000000 +
 400                                 device->Frequency-1) / device->Frequency;
 401
 402     if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
 403         device->Frequency = OutputType.Format.nSamplesPerSec;
 404     if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
 405     {
 406         if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
 407             device->FmtChans = DevFmtMono;
 408         else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
 409             device->FmtChans = DevFmtStereo;
 410         else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
 411             device->FmtChans = DevFmtQuad;
 412         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
 413             device->FmtChans = DevFmtX51;
 414         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE)
 415             device->FmtChans = DevFmtX51Side;
 416         else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
 417             device->FmtChans = DevFmtX61;
 418         else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
 419             device->FmtChans = DevFmtX71;
 420         else
 421             ERR("Unhandled channel config: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
 422     }
 423
 424     switch(device->FmtChans)
 425     {
 426         case DevFmtMono:
 427             OutputType.Format.nChannels = 1;
 428             OutputType.dwChannelMask = MONO;
 429             break;
 430         case DevFmtStereo:
 431             OutputType.Format.nChannels = 2;
 432             OutputType.dwChannelMask = STEREO;
 433             break;
 434         case DevFmtQuad:
 435             OutputType.Format.nChannels = 4;
 436             OutputType.dwChannelMask = QUAD;
 437             break;
 438         case DevFmtX51:
 439             OutputType.Format.nChannels = 6;
 440             OutputType.dwChannelMask = X5DOT1;
 441             break;
 442         case DevFmtX51Side:
 443             OutputType.Format.nChannels = 6;
 444             OutputType.dwChannelMask = X5DOT1SIDE;
 445             break;
 446         case DevFmtX61:
 447             OutputType.Format.nChannels = 7;
 448             OutputType.dwChannelMask = X6DOT1;
 449             break;
 450         case DevFmtX71:
 451             OutputType.Format.nChannels = 8;
 452             OutputType.dwChannelMask = X7DOT1;
 453             break;
 454     }
 455     switch(device->FmtType)
 456     {
 457         case DevFmtByte:
 458             device->FmtType = DevFmtUByte;
 459             /* fall-through */
 460         case DevFmtUByte:
 461             OutputType.Format.wBitsPerSample = 8;
 462             OutputType.Samples.wValidBitsPerSample = 8;
 463             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 464             break;
 465         case DevFmtUShort:
 466             device->FmtType = DevFmtShort;
 467             /* fall-through */
 468         case DevFmtShort:
 469             OutputType.Format.wBitsPerSample = 16;
 470             OutputType.Samples.wValidBitsPerSample = 16;
 471             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 472             break;
 473         case DevFmtUInt:
 474             device->FmtType = DevFmtInt;
 475             /* fall-through */
 476         case DevFmtInt:
 477             OutputType.Format.wBitsPerSample = 32;
 478             OutputType.Samples.wValidBitsPerSample = 32;
 479             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 480             break;
 481         case DevFmtFloat:
 482             OutputType.Format.wBitsPerSample = 32;
 483             OutputType.Samples.wValidBitsPerSample = 32;
 484             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 485             break;
 486     }
 487     OutputType.Format.nSamplesPerSec = device->Frequency;
 488
 489     OutputType.Format.nBlockAlign = OutputType.Format.nChannels *
 490                                     OutputType.Format.wBitsPerSample / 8;
 491     OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
 492                                         OutputType.Format.nBlockAlign;
 493
 494     hr = IAudioClient_IsFormatSupported(data->client, AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
 495     if(FAILED(hr))
 496     {
 497         ERR("Failed to check format support: 0x%08lx\n", hr);
 498         hr = IAudioClient_GetMixFormat(data->client, &wfx);
 499     }
 500     if(FAILED(hr))
 501     {
 502         ERR("Failed to find a supported format: 0x%08lx\n", hr);
 503         return hr;
 504     }
 505
 506     if(wfx != NULL)
 507     {
 508         if(!MakeExtensible(&OutputType, wfx))
 509         {
 510             CoTaskMemFree(wfx);
 511             return E_FAIL;
 512         }
 513         CoTaskMemFree(wfx);
 514         wfx = NULL;
 515
 516         device->Frequency = OutputType.Format.nSamplesPerSec;
 517         if(OutputType.Format.nChannels == 1 && OutputType.dwChannelMask == MONO)
 518             device->FmtChans = DevFmtMono;
 519         else if(OutputType.Format.nChannels == 2 && OutputType.dwChannelMask == STEREO)
 520             device->FmtChans = DevFmtStereo;
 521         else if(OutputType.Format.nChannels == 4 && OutputType.dwChannelMask == QUAD)
 522             device->FmtChans = DevFmtQuad;
 523         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1)
 524             device->FmtChans = DevFmtX51;
 525         else if(OutputType.Format.nChannels == 6 && OutputType.dwChannelMask == X5DOT1SIDE)
 526             device->FmtChans = DevFmtX51Side;
 527         else if(OutputType.Format.nChannels == 7 && OutputType.dwChannelMask == X6DOT1)
 528             device->FmtChans = DevFmtX61;
 529         else if(OutputType.Format.nChannels == 8 && OutputType.dwChannelMask == X7DOT1)
 530             device->FmtChans = DevFmtX71;
 531         else
 532         {
 533             ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels, OutputType.dwChannelMask);
 534             device->FmtChans = DevFmtStereo;
 535             OutputType.Format.nChannels = 2;
 536             OutputType.dwChannelMask = STEREO;
 537         }
 538
 539         if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 540         {
 541             if(OutputType.Format.wBitsPerSample == 8)
 542                 device->FmtType = DevFmtUByte;
 543             else if(OutputType.Format.wBitsPerSample == 16)
 544                 device->FmtType = DevFmtShort;
 545             else if(OutputType.Format.wBitsPerSample == 32)
 546                 device->FmtType = DevFmtInt;
 547             else
 548             {
 549                 device->FmtType = DevFmtShort;
 550                 OutputType.Format.wBitsPerSample = 16;
 551             }
 552         }
 553         else if(IsEqualGUID(&OutputType.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
 554         {
 555             device->FmtType = DevFmtFloat;
 556             OutputType.Format.wBitsPerSample = 32;
 557         }
 558         else
 559         {
 560             ERR("Unhandled format sub-type\n");
 561             device->FmtType = DevFmtShort;
 562             OutputType.Format.wBitsPerSample = 16;
 563             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 564         }
 565         OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
 566     }
 567
 568     SetDefaultWFXChannelOrder(device);
 569
 570     hr = IAudioClient_Initialize(data->client, AUDCLNT_SHAREMODE_SHARED,
 571                                  AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
 572                                  buf_time, 0, &OutputType.Format, NULL);
 573     if(FAILED(hr))
 574     {
 575         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
 576         return hr;
 577     }
 578
 579     hr = IAudioClient_GetDevicePeriod(data->client, &min_per, NULL);
 580     if(SUCCEEDED(hr))
 581     {
 582         min_len = (min_per*device->Frequency + 10000000-1) / 10000000;
 583         hr = IAudioClient_GetBufferSize(data->client, &buffer_len);
 584     }
 585     if(FAILED(hr))
 586     {
 587         ERR("Failed to get audio buffer info: 0x%08lx\n", hr);
 588         return hr;
 589     }
 590
 591     device->UpdateSize = min_len;
 592     device->NumUpdates = buffer_len / device->UpdateSize;
 593     if(device->NumUpdates <= 1)
 594     {
 595         device->NumUpdates = 1;
 596         ERR("Audio client returned buffer_len < period*2; expect break up\n");
 597     }
 598
 599     ResetEvent(data->hNotifyEvent);
 600     hr = IAudioClient_SetEventHandle(data->client, data->hNotifyEvent);
 601     if(SUCCEEDED(hr))
 602         hr = IAudioClient_Start(data->client);
 603     if(FAILED(hr))
 604     {
 605         ERR("Failed to start audio client: 0x%08lx\n", hr);
 606         return hr;
 607     }
 608
 609     data->thread = StartThread(MMDevApiProc, device);
 610     if(!data->thread)
 611     {
 612         IAudioClient_Stop(data->client);
 613         ERR("Failed to start thread\n");
 614         return E_FAIL;
 615     }
 616
 617     return hr;
 618 }
 619
 620
 621 static DWORD CALLBACK MMDevApiMsgProc(void *ptr)
 622 {
 623     ThreadRequest *req = ptr;
 624     IMMDeviceEnumerator *Enumerator;
 625     ALuint deviceCount = 0;
 626     MMDevApiData *data;
 627     ALCdevice *device;
 628     HRESULT hr, cohr;
 629     MSG msg;
 630
 631     TRACE("Starting message thread\n");
 632
 633     cohr = CoInitialize(NULL);
 634     if(FAILED(cohr))
 635     {
 636         WARN("Failed to initialize COM: 0x%08lx\n", cohr);
 637         req->result = cohr;
 638         SetEvent(req->FinishedEvt);
 639         return 0;
 640     }
 641
 642     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 643     if(FAILED(hr))
 644     {
 645         WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
 646         CoUninitialize();
 647         req->result = hr;
 648         SetEvent(req->FinishedEvt);
 649         return 0;
 650     }
 651     Enumerator = ptr;
 652     IMMDeviceEnumerator_Release(Enumerator);
 653     Enumerator = NULL;
 654
 655     CoUninitialize();
 656
 657     req->result = S_OK;
 658     SetEvent(req->FinishedEvt);
 659
 660     TRACE("Starting message loop\n");
 661     while(GetMessage(&msg, NULL, 0, 0))
 662     {
 663         TRACE("Got message %u\n", msg.message);
 664         switch(msg.message)
 665         {
 666         case WM_USER_OpenDevice:
 667             req = (ThreadRequest*)msg.wParam;
 668             device = (ALCdevice*)msg.lParam;
 669             data = device->ExtraData;
 670
 671             hr = cohr = S_OK;
 672             if(++deviceCount == 1)
 673                 hr = cohr = CoInitialize(NULL);
 674             if(SUCCEEDED(hr))
 675                 hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 676             if(SUCCEEDED(hr))
 677             {
 678                 Enumerator = ptr;
 679                 if(IsEqualGUID(&data->guid, &GUID_NULL))
 680                     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &data->mmdev);
 681                 else
 682                     hr = get_mmdevice_by_guid(Enumerator, eRender, &data->guid, &data->mmdev);
 683                 IMMDeviceEnumerator_Release(Enumerator);
 684                 Enumerator = NULL;
 685             }
 686             if(SUCCEEDED(hr))
 687                 hr = IMMDevice_Activate(data->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
 688             if(SUCCEEDED(hr))
 689                 data->client = ptr;
 690
 691             if(FAILED(hr))
 692             {
 693                 if(data->mmdev)
 694                     IMMDevice_Release(data->mmdev);
 695                 data->mmdev = NULL;
 696                 if(--deviceCount == 0 && SUCCEEDED(cohr))
 697                     CoUninitialize();
 698             }
 699
 700             req->result = hr;
 701             SetEvent(req->FinishedEvt);
 702             continue;
 703
 704         case WM_USER_ResetDevice:
 705             req = (ThreadRequest*)msg.wParam;
 706             device = (ALCdevice*)msg.lParam;
 707
 708             req->result = DoReset(device);
 709             SetEvent(req->FinishedEvt);
 710             continue;
 711
 712         case WM_USER_StopDevice:
 713             req = (ThreadRequest*)msg.wParam;
 714             device = (ALCdevice*)msg.lParam;
 715             data = device->ExtraData;
 716
 717             if(data->thread)
 718             {
 719                 data->killNow = 1;
 720                 StopThread(data->thread);
 721                 data->thread = NULL;
 722
 723                 data->killNow = 0;
 724
 725                 IAudioClient_Stop(data->client);
 726             }
 727
 728             req->result = S_OK;
 729             SetEvent(req->FinishedEvt);
 730             continue;
 731
 732         case WM_USER_CloseDevice:
 733             req = (ThreadRequest*)msg.wParam;
 734             device = (ALCdevice*)msg.lParam;
 735             data = device->ExtraData;
 736
 737             IAudioClient_Release(data->client);
 738             data->client = NULL;
 739
 740             IMMDevice_Release(data->mmdev);
 741             data->mmdev = NULL;
 742
 743             if(--deviceCount == 0)
 744                 CoUninitialize();
 745
 746             req->result = S_OK;
 747             SetEvent(req->FinishedEvt);
 748             continue;
 749
 750         case WM_USER_Enumerate:
 751             req = (ThreadRequest*)msg.wParam;
 752
 753             hr = cohr = S_OK;
 754             if(++deviceCount == 1)
 755                 hr = cohr = CoInitialize(NULL);
 756             if(SUCCEEDED(hr))
 757                 hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
 758             if(SUCCEEDED(hr))
 759             {
 760                 EDataFlow flowdir;
 761                 DevMap **devlist;
 762                 ALuint *numdevs;
 763                 ALuint i;
 764
 765                 Enumerator = ptr;
 766                 if(msg.lParam == CAPTURE_DEVICE_PROBE)
 767                 {
 768                     flowdir = eCapture;
 769                     devlist = &CaptureDeviceList;
 770                     numdevs = &NumCaptureDevices;
 771                 }
 772                 else
 773                 {
 774                     flowdir = eRender;
 775                     devlist = &PlaybackDeviceList;
 776                     numdevs = &NumPlaybackDevices;
 777                 }
 778
 779                 for(i = 0;i < *numdevs;i++)
 780                     free((*devlist)[i].name);
 781                 free(*devlist);
 782                 *devlist = NULL;
 783                 *numdevs = 0;
 784
 785                 *devlist = ProbeDevices(Enumerator, flowdir, numdevs);
 786
 787                 IMMDeviceEnumerator_Release(Enumerator);
 788                 Enumerator = NULL;
 789             }
 790
 791             if(--deviceCount == 0 && SUCCEEDED(cohr))
 792                 CoUninitialize();
 793
 794             req->result = S_OK;
 795             SetEvent(req->FinishedEvt);
 796             continue;
 797
 798         default:
 799             ERR("Unexpected message: %u\n", msg.message);
 800             continue;
 801         }
 802     }
 803     TRACE("Message loop finished\n");
 804
 805     return 0;
 806 }
 807
 808
 809 static BOOL MMDevApiLoad(void)
 810 {
 811     static HRESULT InitResult;
 812     if(!ThreadHdl)
 813     {
 814         ThreadRequest req;
 815         InitResult = E_FAIL;
 816
 817         req.FinishedEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
 818         if(req.FinishedEvt == NULL)
 819             ERR("Failed to create event: %lu\n", GetLastError());
 820         else
 821         {
 822             ThreadHdl = CreateThread(NULL, 0, MMDevApiMsgProc, &req, 0, &ThreadID);
 823             if(ThreadHdl != NULL)
 824                 InitResult = WaitForResponse(&req);
 825             CloseHandle(req.FinishedEvt);
 826         }
 827     }
 828     return SUCCEEDED(InitResult);
 829 }
 830
 831
 832 static ALCenum MMDevApiOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
 833 {
 834     MMDevApiData *data = NULL;
 835     HRESULT hr;
 836
 837     //Initialise requested device
 838     data = calloc(1, sizeof(MMDevApiData));
 839     if(!data)
 840         return ALC_OUT_OF_MEMORY;
 841     device->ExtraData = data;
 842
 843     hr = S_OK;
 844     data->hNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 845     data->MsgEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 846     if(data->hNotifyEvent == NULL || data->MsgEvent == NULL)
 847         hr = E_FAIL;
 848
 849     if(SUCCEEDED(hr))
 850     {
 851         data->guid = GUID_NULL;
 852
 853         if(!deviceName)
 854             deviceName = mmDevice;
 855         else if(strcmp(deviceName, mmDevice) != 0)
 856         {
 857             ALuint i;
 858
 859             if(!PlaybackDeviceList)
 860             {
 861                 ThreadRequest req = { data->MsgEvent, 0 };
 862
 863                 if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, ALL_DEVICE_PROBE))
 864                     (void)WaitForResponse(&req);
 865             }
 866
 867             hr = E_FAIL;
 868             for(i = 0;i < NumPlaybackDevices;i++)
 869             {
 870                 if(PlaybackDeviceList[i].name &&
 871                    strcmp(deviceName, PlaybackDeviceList[i].name) == 0)
 872                 {
 873                     data->guid = PlaybackDeviceList[i].guid;
 874                     hr = S_OK;
 875                     break;
 876                 }
 877             }
 878         }
 879     }
 880
 881     if(SUCCEEDED(hr))
 882     {
 883         ThreadRequest req = { data->MsgEvent, 0 };
 884
 885         hr = E_FAIL;
 886         if(PostThreadMessage(ThreadID, WM_USER_OpenDevice, (WPARAM)&req, (LPARAM)device))
 887             hr = WaitForResponse(&req);
 888     }
 889
 890     if(FAILED(hr))
 891     {
 892         if(data->hNotifyEvent != NULL)
 893             CloseHandle(data->hNotifyEvent);
 894         data->hNotifyEvent = NULL;
 895         if(data->MsgEvent != NULL)
 896             CloseHandle(data->MsgEvent);
 897         data->MsgEvent = NULL;
 898
 899         free(data);
 900         device->ExtraData = NULL;
 901
 902         ERR("Device init failed: 0x%08lx\n", hr);
 903         return ALC_INVALID_VALUE;
 904     }
 905
 906     device->szDeviceName = strdup(deviceName);
 907     return ALC_NO_ERROR;
 908 }
 909
 910 static void MMDevApiClosePlayback(ALCdevice *device)
 911 {
 912     MMDevApiData *data = device->ExtraData;
 913     ThreadRequest req = { data->MsgEvent, 0 };
 914
 915     if(PostThreadMessage(ThreadID, WM_USER_CloseDevice, (WPARAM)&req, (LPARAM)device))
 916         (void)WaitForResponse(&req);
 917
 918     CloseHandle(data->MsgEvent);
 919     data->MsgEvent = NULL;
 920
 921     CloseHandle(data->hNotifyEvent);
 922     data->hNotifyEvent = NULL;
 923
 924     free(data);
 925     device->ExtraData = NULL;
 926 }
 927
 928 static ALCboolean MMDevApiResetPlayback(ALCdevice *device)
 929 {
 930     MMDevApiData *data = device->ExtraData;
 931     ThreadRequest req = { data->MsgEvent, 0 };
 932     HRESULT hr = E_FAIL;
 933
 934     if(PostThreadMessage(ThreadID, WM_USER_ResetDevice, (WPARAM)&req, (LPARAM)device))
 935         hr = WaitForResponse(&req);
 936
 937     return SUCCEEDED(hr) ? ALC_TRUE : ALC_FALSE;
 938 }
 939
 940 static void MMDevApiStopPlayback(ALCdevice *device)
 941 {
 942     MMDevApiData *data = device->ExtraData;
 943     ThreadRequest req = { data->MsgEvent, 0 };
 944
 945     if(PostThreadMessage(ThreadID, WM_USER_StopDevice, (WPARAM)&req, (LPARAM)device))
 946         (void)WaitForResponse(&req);
 947 }
 948
 949
 950 static const BackendFuncs MMDevApiFuncs = {
 951     MMDevApiOpenPlayback,
 952     MMDevApiClosePlayback,
 953     MMDevApiResetPlayback,
 954     MMDevApiStopPlayback,
 955     NULL,
 956     NULL,
 957     NULL,
 958     NULL,
 959     NULL,
 960     NULL
 961 };
 962
 963
 964 ALCboolean alcMMDevApiInit(BackendFuncs *FuncList)
 965 {
 966     if(!MMDevApiLoad())
 967         return ALC_FALSE;
 968     *FuncList = MMDevApiFuncs;
 969     return ALC_TRUE;
 970 }
 971
 972 void alcMMDevApiDeinit(void)
 973 {
 974     if(ThreadHdl)
 975     {
 976         TRACE("Sending WM_QUIT to Thread %04lx\n", ThreadID);
 977         PostThreadMessage(ThreadID, WM_QUIT, 0, 0);
 978         CloseHandle(ThreadHdl);
 979         ThreadHdl = NULL;
 980     }
 981 }
 982
 983 void alcMMDevApiProbe(enum DevProbe type)
 984 {
 985     ThreadRequest req;
 986     HRESULT hr = E_FAIL;
 987
 988     switch(type)
 989     {
 990         case DEVICE_PROBE:
 991             AppendDeviceList(mmDevice);
 992             break;
 993
 994         case ALL_DEVICE_PROBE:
 995             req.FinishedEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
 996             if(req.FinishedEvt == NULL)
 997                 ERR("Failed to create event: %lu\n", GetLastError());
 998             else if(PostThreadMessage(ThreadID, WM_USER_Enumerate, (WPARAM)&req, type))
 999                 hr = WaitForResponse(&req);
1000             if(SUCCEEDED(hr))
1001             {
1002                 ALuint i;
1003                 for(i = 0;i < NumPlaybackDevices;i++)
1004                 {
1005                     if(PlaybackDeviceList[i].name)
1006                         AppendAllDeviceList(PlaybackDeviceList[i].name);
1007                 }
1008             }
1009             if(req.FinishedEvt != NULL)
1010                 CloseHandle(req.FinishedEvt);
1011             break;
1012
1013         case CAPTURE_DEVICE_PROBE:
1014             break;
1015     }
1016 }