alc/backends/wasapi.cpp

   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 #include "backends/wasapi.h"
  24
  25 #define WIN32_LEAN_AND_MEAN
  26 #include <windows.h>
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <memory.h>
  31
  32 #include <wtypes.h>
  33 #include <mmdeviceapi.h>
  34 #include <audioclient.h>
  35 #include <cguid.h>
  36 #include <devpropdef.h>
  37 #include <mmreg.h>
  38 #include <propsys.h>
  39 #include <propkey.h>
  40 #include <devpkey.h>
  41 #ifndef _WAVEFORMATEXTENSIBLE_
  42 #include <ks.h>
  43 #include <ksmedia.h>
  44 #endif
  45
  46 #include <algorithm>
  47 #include <atomic>
  48 #include <chrono>
  49 #include <condition_variable>
  50 #include <deque>
  51 #include <functional>
  52 #include <future>
  53 #include <mutex>
  54 #include <string>
  55 #include <thread>
  56 #include <vector>
  57
  58 #include "alcmain.h"
  59 #include "alexcpt.h"
  60 #include "alu.h"
  61 #include "compat.h"
  62 #include "converter.h"
  63 #include "logging.h"
  64 #include "ringbuffer.h"
  65 #include "strutils.h"
  66 #include "threads.h"
  67
  68
  69 /* Some headers seem to define these as macros for __uuidof, which is annoying
  70  * since some headers don't declare them at all. Hopefully the ifdef is enough
  71  * to tell if they need to be declared.
  72  */
  73 #ifndef KSDATAFORMAT_SUBTYPE_PCM
  74 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  75 #endif
  76 #ifndef KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
  77 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  78 #endif
  79
  80 DEFINE_DEVPROPKEY(DEVPKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80,0x20, 0x67,0xd1,0x46,0xa8,0x50,0xe0, 14);
  81 DEFINE_PROPERTYKEY(PKEY_AudioEndpoint_FormFactor, 0x1da5d803, 0xd492, 0x4edd, 0x8c,0x23, 0xe0,0xc0,0xff,0xee,0x7f,0x0e, 0);
  82 DEFINE_PROPERTYKEY(PKEY_AudioEndpoint_GUID, 0x1da5d803, 0xd492, 0x4edd, 0x8c, 0x23,0xe0, 0xc0,0xff,0xee,0x7f,0x0e, 4 );
  83
  84
  85 namespace {
  86
  87 using std::chrono::milliseconds;
  88 using std::chrono::seconds;
  89
  90 using ReferenceTime = std::chrono::duration<REFERENCE_TIME,std::ratio<1,10000000>>;
  91
  92 inline constexpr ReferenceTime operator "" _reftime(unsigned long long int n) noexcept
  93 { return ReferenceTime{static_cast<REFERENCE_TIME>(n)}; }
  94
  95
  96 #define MONO SPEAKER_FRONT_CENTER
  97 #define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
  98 #define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
  99 #define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
 100 #define X5DOT1REAR (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
 101 #define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
 102 #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)
 103
 104 constexpr inline DWORD MaskFromTopBits(DWORD b) noexcept
 105 {
 106     b |= b>>1;
 107     b |= b>>2;
 108     b |= b>>4;
 109     b |= b>>8;
 110     b |= b>>16;
 111     return b;
 112 }
 113 constexpr DWORD MonoMask{MaskFromTopBits(MONO)};
 114 constexpr DWORD StereoMask{MaskFromTopBits(STEREO)};
 115 constexpr DWORD QuadMask{MaskFromTopBits(QUAD)};
 116 constexpr DWORD X51Mask{MaskFromTopBits(X5DOT1)};
 117 constexpr DWORD X51RearMask{MaskFromTopBits(X5DOT1REAR)};
 118 constexpr DWORD X61Mask{MaskFromTopBits(X6DOT1)};
 119 constexpr DWORD X71Mask{MaskFromTopBits(X7DOT1)};
 120
 121 #define DEVNAME_HEAD "OpenAL Soft on "
 122
 123
 124 /* Scales the given reftime value, ceiling the result. */
 125 inline ALuint RefTime2Samples(const ReferenceTime &val, ALuint srate)
 126 {
 127     const auto retval = (val*srate + (seconds{1}-1_reftime)) / seconds{1};
 128     return static_cast<ALuint>(retval);
 129 }
 130
 131
 132 class GuidPrinter {
 133     char mMsg[64];
 134
 135 public:
 136     GuidPrinter(const GUID &guid)
 137     {
 138         std::snprintf(mMsg, al::size(mMsg), "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 139             DWORD{guid.Data1}, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], guid.Data4[2],
 140             guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
 141     }
 142     const char *c_str() const { return mMsg; }
 143 };
 144
 145 struct PropVariant {
 146     PROPVARIANT mProp;
 147
 148 public:
 149     PropVariant() { PropVariantInit(&mProp); }
 150     ~PropVariant() { clear(); }
 151
 152     void clear() { PropVariantClear(&mProp); }
 153
 154     PROPVARIANT* get() noexcept { return &mProp; }
 155
 156     PROPVARIANT& operator*() noexcept { return mProp; }
 157     const PROPVARIANT& operator*() const noexcept { return mProp; }
 158
 159     PROPVARIANT* operator->() noexcept { return &mProp; }
 160     const PROPVARIANT* operator->() const noexcept { return &mProp; }
 161 };
 162
 163 struct DevMap {
 164     std::string name;
 165     std::string endpoint_guid; // obtained from PKEY_AudioEndpoint_GUID , set to "Unknown device GUID" if absent.
 166     std::wstring devid;
 167
 168     template<typename T0, typename T1, typename T2>
 169     DevMap(T0&& name_, T1&& guid_, T2&& devid_)
 170       : name{std::forward<T0>(name_)}
 171       , endpoint_guid{std::forward<T1>(guid_)}
 172       , devid{std::forward<T2>(devid_)}
 173     { }
 174 };
 175
 176 bool checkName(const al::vector<DevMap> &list, const std::string &name)
 177 {
 178     return std::find_if(list.cbegin(), list.cend(),
 179         [&name](const DevMap &entry) -> bool
 180         { return entry.name == name; }
 181     ) != list.cend();
 182 }
 183
 184 al::vector<DevMap> PlaybackDevices;
 185 al::vector<DevMap> CaptureDevices;
 186
 187
 188 using NameGUIDPair = std::pair<std::string,std::string>;
 189 NameGUIDPair get_device_name_and_guid(IMMDevice *device)
 190 {
 191     std::string name{DEVNAME_HEAD};
 192     std::string guid;
 193
 194     IPropertyStore *ps;
 195     HRESULT hr = device->OpenPropertyStore(STGM_READ, &ps);
 196     if(FAILED(hr))
 197     {
 198         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 199         return { name+"Unknown Device Name", "Unknown Device GUID" };
 200     }
 201
 202     PropVariant pvprop;
 203     hr = ps->GetValue(reinterpret_cast<const PROPERTYKEY&>(DEVPKEY_Device_FriendlyName), pvprop.get());
 204     if(FAILED(hr))
 205     {
 206         WARN("GetValue Device_FriendlyName failed: 0x%08lx\n", hr);
 207         name += "Unknown Device Name";
 208     }
 209     else if(pvprop->vt == VT_LPWSTR)
 210         name += wstr_to_utf8(pvprop->pwszVal);
 211     else
 212     {
 213         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvprop->vt);
 214         name += "Unknown Device Name";
 215     }
 216
 217     pvprop.clear();
 218     hr = ps->GetValue(reinterpret_cast<const PROPERTYKEY&>(PKEY_AudioEndpoint_GUID), pvprop.get());
 219     if(FAILED(hr))
 220     {
 221         WARN("GetValue AudioEndpoint_GUID failed: 0x%08lx\n", hr);
 222         guid = "Unknown Device GUID";
 223     }
 224     else if(pvprop->vt == VT_LPWSTR)
 225         guid = wstr_to_utf8(pvprop->pwszVal);
 226     else
 227     {
 228         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvprop->vt);
 229         guid = "Unknown Device GUID";
 230     }
 231
 232     ps->Release();
 233
 234     return {name, guid};
 235 }
 236
 237 void get_device_formfactor(IMMDevice *device, EndpointFormFactor *formfactor)
 238 {
 239     IPropertyStore *ps;
 240     HRESULT hr = device->OpenPropertyStore(STGM_READ, &ps);
 241     if(FAILED(hr))
 242     {
 243         WARN("OpenPropertyStore failed: 0x%08lx\n", hr);
 244         return;
 245     }
 246
 247     PropVariant pvform;
 248     hr = ps->GetValue(reinterpret_cast<const PROPERTYKEY&>(PKEY_AudioEndpoint_FormFactor), pvform.get());
 249     if(FAILED(hr))
 250         WARN("GetValue AudioEndpoint_FormFactor failed: 0x%08lx\n", hr);
 251     else if(pvform->vt == VT_UI4)
 252         *formfactor = static_cast<EndpointFormFactor>(pvform->ulVal);
 253     else if(pvform->vt == VT_EMPTY)
 254         *formfactor = UnknownFormFactor;
 255     else
 256         WARN("Unexpected PROPVARIANT type: 0x%04x\n", pvform->vt);
 257
 258     ps->Release();
 259 }
 260
 261
 262 void add_device(IMMDevice *device, const WCHAR *devid, al::vector<DevMap> &list)
 263 {
 264     std::string basename, guidstr;
 265     std::tie(basename, guidstr) = get_device_name_and_guid(device);
 266
 267     int count{1};
 268     std::string newname{basename};
 269     while(checkName(list, newname))
 270     {
 271         newname = basename;
 272         newname += " #";
 273         newname += std::to_string(++count);
 274     }
 275     list.emplace_back(std::move(newname), std::move(guidstr), devid);
 276     const DevMap &newentry = list.back();
 277
 278     TRACE("Got device \"%s\", \"%s\", \"%ls\"\n", newentry.name.c_str(),
 279           newentry.endpoint_guid.c_str(), newentry.devid.c_str());
 280 }
 281
 282 WCHAR *get_device_id(IMMDevice *device)
 283 {
 284     WCHAR *devid;
 285
 286     HRESULT hr = device->GetId(&devid);
 287     if(FAILED(hr))
 288     {
 289         ERR("Failed to get device id: %lx\n", hr);
 290         return nullptr;
 291     }
 292
 293     return devid;
 294 }
 295
 296 void probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, al::vector<DevMap> &list)
 297 {
 298     al::vector<DevMap>{}.swap(list);
 299
 300     IMMDeviceCollection *coll;
 301     HRESULT hr{devenum->EnumAudioEndpoints(flowdir, DEVICE_STATE_ACTIVE, &coll)};
 302     if(FAILED(hr))
 303     {
 304         ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
 305         return;
 306     }
 307
 308     IMMDevice *defdev{nullptr};
 309     WCHAR *defdevid{nullptr};
 310     UINT count{0};
 311     hr = coll->GetCount(&count);
 312     if(SUCCEEDED(hr) && count > 0)
 313     {
 314         list.reserve(count);
 315
 316         hr = devenum->GetDefaultAudioEndpoint(flowdir, eMultimedia, &defdev);
 317     }
 318     if(SUCCEEDED(hr) && defdev != nullptr)
 319     {
 320         defdevid = get_device_id(defdev);
 321         if(defdevid)
 322             add_device(defdev, defdevid, list);
 323     }
 324
 325     for(UINT i{0};i < count;++i)
 326     {
 327         IMMDevice *device;
 328         hr = coll->Item(i, &device);
 329         if(FAILED(hr)) continue;
 330
 331         WCHAR *devid{get_device_id(device)};
 332         if(devid)
 333         {
 334             if(!defdevid || wcscmp(devid, defdevid) != 0)
 335                 add_device(device, devid, list);
 336             CoTaskMemFree(devid);
 337         }
 338         device->Release();
 339     }
 340
 341     if(defdev) defdev->Release();
 342     if(defdevid) CoTaskMemFree(defdevid);
 343     coll->Release();
 344 }
 345
 346
 347 bool MakeExtensible(WAVEFORMATEXTENSIBLE *out, const WAVEFORMATEX *in)
 348 {
 349     *out = WAVEFORMATEXTENSIBLE{};
 350     if(in->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 351     {
 352         *out = *CONTAINING_RECORD(in, const WAVEFORMATEXTENSIBLE, Format);
 353         out->Format.cbSize = sizeof(*out) - sizeof(out->Format);
 354     }
 355     else if(in->wFormatTag == WAVE_FORMAT_PCM)
 356     {
 357         out->Format = *in;
 358         out->Format.cbSize = 0;
 359         out->Samples.wValidBitsPerSample = out->Format.wBitsPerSample;
 360         if(out->Format.nChannels == 1)
 361             out->dwChannelMask = MONO;
 362         else if(out->Format.nChannels == 2)
 363             out->dwChannelMask = STEREO;
 364         else
 365             ERR("Unhandled PCM channel count: %d\n", out->Format.nChannels);
 366         out->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 367     }
 368     else if(in->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 369     {
 370         out->Format = *in;
 371         out->Format.cbSize = 0;
 372         out->Samples.wValidBitsPerSample = out->Format.wBitsPerSample;
 373         if(out->Format.nChannels == 1)
 374             out->dwChannelMask = MONO;
 375         else if(out->Format.nChannels == 2)
 376             out->dwChannelMask = STEREO;
 377         else
 378             ERR("Unhandled IEEE float channel count: %d\n", out->Format.nChannels);
 379         out->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 380     }
 381     else
 382     {
 383         ERR("Unhandled format tag: 0x%04x\n", in->wFormatTag);
 384         return false;
 385     }
 386     return true;
 387 }
 388
 389 void TraceFormat(const char *msg, const WAVEFORMATEX *format)
 390 {
 391     constexpr size_t fmtex_extra_size{sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX)};
 392     if(format->wFormatTag == WAVE_FORMAT_EXTENSIBLE && format->cbSize >= fmtex_extra_size)
 393     {
 394         const WAVEFORMATEXTENSIBLE *fmtex{
 395             CONTAINING_RECORD(format, const WAVEFORMATEXTENSIBLE, Format)};
 396         TRACE("%s:\n"
 397             "    FormatTag      = 0x%04x\n"
 398             "    Channels       = %d\n"
 399             "    SamplesPerSec  = %lu\n"
 400             "    AvgBytesPerSec = %lu\n"
 401             "    BlockAlign     = %d\n"
 402             "    BitsPerSample  = %d\n"
 403             "    Size           = %d\n"
 404             "    Samples        = %d\n"
 405             "    ChannelMask    = 0x%lx\n"
 406             "    SubFormat      = %s\n",
 407             msg, fmtex->Format.wFormatTag, fmtex->Format.nChannels, fmtex->Format.nSamplesPerSec,
 408             fmtex->Format.nAvgBytesPerSec, fmtex->Format.nBlockAlign, fmtex->Format.wBitsPerSample,
 409             fmtex->Format.cbSize, fmtex->Samples.wReserved, fmtex->dwChannelMask,
 410             GuidPrinter{fmtex->SubFormat}.c_str());
 411     }
 412     else
 413         TRACE("%s:\n"
 414             "    FormatTag      = 0x%04x\n"
 415             "    Channels       = %d\n"
 416             "    SamplesPerSec  = %lu\n"
 417             "    AvgBytesPerSec = %lu\n"
 418             "    BlockAlign     = %d\n"
 419             "    BitsPerSample  = %d\n"
 420             "    Size           = %d\n",
 421             msg, format->wFormatTag, format->nChannels, format->nSamplesPerSec,
 422             format->nAvgBytesPerSec, format->nBlockAlign, format->wBitsPerSample, format->cbSize);
 423 }
 424
 425
 426 enum class MsgType {
 427     OpenDevice,
 428     ResetDevice,
 429     StartDevice,
 430     StopDevice,
 431     CloseDevice,
 432     EnumeratePlayback,
 433     EnumerateCapture,
 434     QuitThread,
 435
 436     Count
 437 };
 438
 439 constexpr char MessageStr[static_cast<size_t>(MsgType::Count)][20]{
 440     "Open Device",
 441     "Reset Device",
 442     "Start Device",
 443     "Stop Device",
 444     "Close Device",
 445     "Enumerate Playback",
 446     "Enumerate Capture",
 447     "Quit"
 448 };
 449
 450
 451 /* Proxy interface used by the message handler. */
 452 struct WasapiProxy {
 453     virtual ~WasapiProxy() = default;
 454
 455     virtual HRESULT openProxy() = 0;
 456     virtual void closeProxy() = 0;
 457
 458     virtual HRESULT resetProxy() = 0;
 459     virtual HRESULT startProxy() = 0;
 460     virtual void  stopProxy() = 0;
 461
 462     struct Msg {
 463         MsgType mType;
 464         WasapiProxy *mProxy;
 465         std::promise<HRESULT> mPromise;
 466     };
 467     static std::deque<Msg> mMsgQueue;
 468     static std::mutex mMsgQueueLock;
 469     static std::condition_variable mMsgQueueCond;
 470
 471     std::future<HRESULT> pushMessage(MsgType type)
 472     {
 473         std::promise<HRESULT> promise;
 474         std::future<HRESULT> future{promise.get_future()};
 475         {
 476             std::lock_guard<std::mutex> _{mMsgQueueLock};
 477             mMsgQueue.emplace_back(Msg{type, this, std::move(promise)});
 478         }
 479         mMsgQueueCond.notify_one();
 480         return future;
 481     }
 482
 483     static std::future<HRESULT> pushMessageStatic(MsgType type)
 484     {
 485         std::promise<HRESULT> promise;
 486         std::future<HRESULT> future{promise.get_future()};
 487         {
 488             std::lock_guard<std::mutex> _{mMsgQueueLock};
 489             mMsgQueue.emplace_back(Msg{type, nullptr, std::move(promise)});
 490         }
 491         mMsgQueueCond.notify_one();
 492         return future;
 493     }
 494
 495     static bool popMessage(Msg &msg)
 496     {
 497         std::unique_lock<std::mutex> lock{mMsgQueueLock};
 498         mMsgQueueCond.wait(lock, []{return !mMsgQueue.empty();});
 499         msg = std::move(mMsgQueue.front());
 500         mMsgQueue.pop_front();
 501         return msg.mType != MsgType::QuitThread;
 502     }
 503
 504     static int messageHandler(std::promise<HRESULT> *promise);
 505 };
 506 std::deque<WasapiProxy::Msg> WasapiProxy::mMsgQueue;
 507 std::mutex WasapiProxy::mMsgQueueLock;
 508 std::condition_variable WasapiProxy::mMsgQueueCond;
 509
 510 int WasapiProxy::messageHandler(std::promise<HRESULT> *promise)
 511 {
 512     TRACE("Starting message thread\n");
 513
 514     HRESULT cohr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 515     if(FAILED(cohr))
 516     {
 517         WARN("Failed to initialize COM: 0x%08lx\n", cohr);
 518         promise->set_value(cohr);
 519         return 0;
 520     }
 521
 522     void *ptr{};
 523     HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
 524         IID_IMMDeviceEnumerator, &ptr)};
 525     if(FAILED(hr))
 526     {
 527         WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
 528         promise->set_value(hr);
 529         CoUninitialize();
 530         return 0;
 531     }
 532     auto Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
 533     Enumerator->Release();
 534     Enumerator = nullptr;
 535     CoUninitialize();
 536
 537     TRACE("Message thread initialization complete\n");
 538     promise->set_value(S_OK);
 539     promise = nullptr;
 540
 541     TRACE("Starting message loop\n");
 542     ALuint deviceCount{0};
 543     Msg msg;
 544     while(popMessage(msg))
 545     {
 546         TRACE("Got message \"%s\" (0x%04x, this=%p)\n",
 547             MessageStr[static_cast<size_t>(msg.mType)], static_cast<int>(msg.mType),
 548             decltype(std::declval<void*>()){msg.mProxy});
 549
 550         switch(msg.mType)
 551         {
 552         case MsgType::OpenDevice:
 553             hr = cohr = S_OK;
 554             if(++deviceCount == 1)
 555                 hr = cohr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 556             if(SUCCEEDED(hr))
 557                 hr = msg.mProxy->openProxy();
 558             msg.mPromise.set_value(hr);
 559
 560             if(FAILED(hr))
 561             {
 562                 if(--deviceCount == 0 && SUCCEEDED(cohr))
 563                     CoUninitialize();
 564             }
 565             continue;
 566
 567         case MsgType::ResetDevice:
 568             hr = msg.mProxy->resetProxy();
 569             msg.mPromise.set_value(hr);
 570             continue;
 571
 572         case MsgType::StartDevice:
 573             hr = msg.mProxy->startProxy();
 574             msg.mPromise.set_value(hr);
 575             continue;
 576
 577         case MsgType::StopDevice:
 578             msg.mProxy->stopProxy();
 579             msg.mPromise.set_value(S_OK);
 580             continue;
 581
 582         case MsgType::CloseDevice:
 583             msg.mProxy->closeProxy();
 584             msg.mPromise.set_value(S_OK);
 585
 586             if(--deviceCount == 0)
 587                 CoUninitialize();
 588             continue;
 589
 590         case MsgType::EnumeratePlayback:
 591         case MsgType::EnumerateCapture:
 592             hr = cohr = S_OK;
 593             if(++deviceCount == 1)
 594                 hr = cohr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 595             if(SUCCEEDED(hr))
 596                 hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER, IID_IMMDeviceEnumerator, &ptr);
 597             if(FAILED(hr))
 598                 msg.mPromise.set_value(hr);
 599             else
 600             {
 601                 Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
 602
 603                 if(msg.mType == MsgType::EnumeratePlayback)
 604                     probe_devices(Enumerator, eRender, PlaybackDevices);
 605                 else if(msg.mType == MsgType::EnumerateCapture)
 606                     probe_devices(Enumerator, eCapture, CaptureDevices);
 607                 msg.mPromise.set_value(S_OK);
 608
 609                 Enumerator->Release();
 610                 Enumerator = nullptr;
 611             }
 612
 613             if(--deviceCount == 0 && SUCCEEDED(cohr))
 614                 CoUninitialize();
 615             continue;
 616
 617         default:
 618             ERR("Unexpected message: %u\n", static_cast<unsigned int>(msg.mType));
 619             msg.mPromise.set_value(E_FAIL);
 620             continue;
 621         }
 622     }
 623     TRACE("Message loop finished\n");
 624
 625     return 0;
 626 }
 627
 628
 629 struct WasapiPlayback final : public BackendBase, WasapiProxy {
 630     WasapiPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
 631     ~WasapiPlayback() override;
 632
 633     int mixerProc();
 634
 635     void open(const ALCchar *name) override;
 636     HRESULT openProxy() override;
 637     void closeProxy() override;
 638
 639     bool reset() override;
 640     HRESULT resetProxy() override;
 641     void start() override;
 642     HRESULT startProxy() override;
 643     void stop() override;
 644     void stopProxy() override;
 645
 646     ClockLatency getClockLatency() override;
 647
 648     std::wstring mDevId;
 649
 650     HRESULT mOpenStatus{E_FAIL};
 651     IMMDevice *mMMDev{nullptr};
 652     IAudioClient *mClient{nullptr};
 653     IAudioRenderClient *mRender{nullptr};
 654     HANDLE mNotifyEvent{nullptr};
 655
 656     UINT32 mFrameStep{0u};
 657     std::atomic<UINT32> mPadding{0u};
 658
 659     std::mutex mMutex;
 660
 661     std::atomic<bool> mKillNow{true};
 662     std::thread mThread;
 663
 664     DEF_NEWDEL(WasapiPlayback)
 665 };
 666
 667 WasapiPlayback::~WasapiPlayback()
 668 {
 669     if(SUCCEEDED(mOpenStatus))
 670         pushMessage(MsgType::CloseDevice).wait();
 671     mOpenStatus = E_FAIL;
 672
 673     if(mNotifyEvent != nullptr)
 674         CloseHandle(mNotifyEvent);
 675     mNotifyEvent = nullptr;
 676 }
 677
 678
 679 FORCE_ALIGN int WasapiPlayback::mixerProc()
 680 {
 681     HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 682     if(FAILED(hr))
 683     {
 684         ERR("CoInitializeEx(nullptr, COINIT_MULTITHREADED) failed: 0x%08lx\n", hr);
 685         mDevice->handleDisconnect("COM init failed: 0x%08lx", hr);
 686         return 1;
 687     }
 688
 689     SetRTPriority();
 690     althrd_setname(MIXER_THREAD_NAME);
 691
 692     const ALuint update_size{mDevice->UpdateSize};
 693     const UINT32 buffer_len{mDevice->BufferSize};
 694     while(!mKillNow.load(std::memory_order_relaxed))
 695     {
 696         UINT32 written;
 697         hr = mClient->GetCurrentPadding(&written);
 698         if(FAILED(hr))
 699         {
 700             ERR("Failed to get padding: 0x%08lx\n", hr);
 701             mDevice->handleDisconnect("Failed to retrieve buffer padding: 0x%08lx", hr);
 702             break;
 703         }
 704         mPadding.store(written, std::memory_order_relaxed);
 705
 706         ALuint len{buffer_len - written};
 707         if(len < update_size)
 708         {
 709             DWORD res{WaitForSingleObjectEx(mNotifyEvent, 2000, FALSE)};
 710             if(res != WAIT_OBJECT_0)
 711                 ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
 712             continue;
 713         }
 714
 715         BYTE *buffer;
 716         hr = mRender->GetBuffer(len, &buffer);
 717         if(SUCCEEDED(hr))
 718         {
 719             {
 720                 std::lock_guard<std::mutex> _{mMutex};
 721                 mDevice->renderSamples(buffer, len, mFrameStep);
 722                 mPadding.store(written + len, std::memory_order_relaxed);
 723             }
 724             hr = mRender->ReleaseBuffer(len, 0);
 725         }
 726         if(FAILED(hr))
 727         {
 728             ERR("Failed to buffer data: 0x%08lx\n", hr);
 729             mDevice->handleDisconnect("Failed to send playback samples: 0x%08lx", hr);
 730             break;
 731         }
 732     }
 733     mPadding.store(0u, std::memory_order_release);
 734
 735     CoUninitialize();
 736     return 0;
 737 }
 738
 739
 740 void WasapiPlayback::open(const ALCchar *name)
 741 {
 742     HRESULT hr{S_OK};
 743
 744     mNotifyEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
 745     if(mNotifyEvent == nullptr)
 746     {
 747         ERR("Failed to create notify events: %lu\n", GetLastError());
 748         hr = E_FAIL;
 749     }
 750
 751     if(SUCCEEDED(hr))
 752     {
 753         if(name)
 754         {
 755             if(PlaybackDevices.empty())
 756                 pushMessage(MsgType::EnumeratePlayback).wait();
 757
 758             hr = E_FAIL;
 759             auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
 760                 [name](const DevMap &entry) -> bool
 761                 { return entry.name == name || entry.endpoint_guid == name; }
 762             );
 763             if(iter == PlaybackDevices.cend())
 764             {
 765                 std::wstring wname{utf8_to_wstr(name)};
 766                 iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
 767                     [&wname](const DevMap &entry) -> bool
 768                     { return entry.devid == wname; }
 769                 );
 770             }
 771             if(iter == PlaybackDevices.cend())
 772                 WARN("Failed to find device name matching \"%s\"\n", name);
 773             else
 774             {
 775                 mDevId = iter->devid;
 776                 mDevice->DeviceName = iter->name;
 777                 hr = S_OK;
 778             }
 779         }
 780     }
 781
 782     if(SUCCEEDED(hr))
 783         hr = pushMessage(MsgType::OpenDevice).get();
 784     mOpenStatus = hr;
 785
 786     if(FAILED(hr))
 787     {
 788         if(mNotifyEvent != nullptr)
 789             CloseHandle(mNotifyEvent);
 790         mNotifyEvent = nullptr;
 791
 792         mDevId.clear();
 793
 794         throw al::backend_exception{ALC_INVALID_VALUE, "Device init failed: 0x%08lx", hr};
 795     }
 796 }
 797
 798 HRESULT WasapiPlayback::openProxy()
 799 {
 800     void *ptr;
 801     HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER, IID_IMMDeviceEnumerator, &ptr)};
 802     if(SUCCEEDED(hr))
 803     {
 804         auto Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
 805         if(mDevId.empty())
 806             hr = Enumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, &mMMDev);
 807         else
 808             hr = Enumerator->GetDevice(mDevId.c_str(), &mMMDev);
 809         Enumerator->Release();
 810     }
 811     if(SUCCEEDED(hr))
 812         hr = mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr);
 813     if(SUCCEEDED(hr))
 814     {
 815         mClient = static_cast<IAudioClient*>(ptr);
 816         if(mDevice->DeviceName.empty())
 817             mDevice->DeviceName = get_device_name_and_guid(mMMDev).first;
 818     }
 819
 820     if(FAILED(hr))
 821     {
 822         if(mMMDev)
 823             mMMDev->Release();
 824         mMMDev = nullptr;
 825     }
 826
 827     return hr;
 828 }
 829
 830 void WasapiPlayback::closeProxy()
 831 {
 832     if(mClient)
 833         mClient->Release();
 834     mClient = nullptr;
 835
 836     if(mMMDev)
 837         mMMDev->Release();
 838     mMMDev = nullptr;
 839 }
 840
 841
 842 bool WasapiPlayback::reset()
 843 {
 844     HRESULT hr{pushMessage(MsgType::ResetDevice).get()};
 845     if(FAILED(hr))
 846         throw al::backend_exception{ALC_INVALID_VALUE, "0x%08lx", hr};
 847     return true;
 848 }
 849
 850 HRESULT WasapiPlayback::resetProxy()
 851 {
 852     if(mClient)
 853         mClient->Release();
 854     mClient = nullptr;
 855
 856     void *ptr;
 857     HRESULT hr = mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr);
 858     if(FAILED(hr))
 859     {
 860         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
 861         return hr;
 862     }
 863     mClient = static_cast<IAudioClient*>(ptr);
 864
 865     WAVEFORMATEX *wfx;
 866     hr = mClient->GetMixFormat(&wfx);
 867     if(FAILED(hr))
 868     {
 869         ERR("Failed to get mix format: 0x%08lx\n", hr);
 870         return hr;
 871     }
 872
 873     WAVEFORMATEXTENSIBLE OutputType;
 874     if(!MakeExtensible(&OutputType, wfx))
 875     {
 876         CoTaskMemFree(wfx);
 877         return E_FAIL;
 878     }
 879     CoTaskMemFree(wfx);
 880     wfx = nullptr;
 881
 882     const ReferenceTime per_time{ReferenceTime{seconds{mDevice->UpdateSize}} / mDevice->Frequency};
 883     const ReferenceTime buf_time{ReferenceTime{seconds{mDevice->BufferSize}} / mDevice->Frequency};
 884
 885     if(!mDevice->Flags.get<FrequencyRequest>())
 886         mDevice->Frequency = OutputType.Format.nSamplesPerSec;
 887     if(!mDevice->Flags.get<ChannelsRequest>())
 888     {
 889         const uint32_t chancount{OutputType.Format.nChannels};
 890         const DWORD chanmask{OutputType.dwChannelMask};
 891         if(chancount >= 8 && (chanmask&X71Mask) == X7DOT1)
 892             mDevice->FmtChans = DevFmtX71;
 893         else if(chancount >= 7 && (chanmask&X61Mask) == X6DOT1)
 894             mDevice->FmtChans = DevFmtX61;
 895         else if(chancount >= 6 && (chanmask&X51Mask) == X5DOT1)
 896             mDevice->FmtChans = DevFmtX51;
 897         else if(chancount >= 6 && (chanmask&X51RearMask) == X5DOT1REAR)
 898             mDevice->FmtChans = DevFmtX51Rear;
 899         else if(chancount >= 4 && (chanmask&QuadMask) == QUAD)
 900             mDevice->FmtChans = DevFmtQuad;
 901         else if(chancount >= 2 && (chanmask&StereoMask) == STEREO)
 902             mDevice->FmtChans = DevFmtStereo;
 903         else if(chancount >= 1 && (chanmask&MonoMask) == MONO)
 904             mDevice->FmtChans = DevFmtMono;
 905         else
 906             ERR("Unhandled channel config: %d -- 0x%08lx\n", chancount, chanmask);
 907     }
 908
 909     OutputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 910     switch(mDevice->FmtChans)
 911     {
 912     case DevFmtMono:
 913         OutputType.Format.nChannels = 1;
 914         OutputType.dwChannelMask = MONO;
 915         break;
 916     case DevFmtAmbi3D:
 917         mDevice->FmtChans = DevFmtStereo;
 918         /*fall-through*/
 919     case DevFmtStereo:
 920         OutputType.Format.nChannels = 2;
 921         OutputType.dwChannelMask = STEREO;
 922         break;
 923     case DevFmtQuad:
 924         OutputType.Format.nChannels = 4;
 925         OutputType.dwChannelMask = QUAD;
 926         break;
 927     case DevFmtX51:
 928         OutputType.Format.nChannels = 6;
 929         OutputType.dwChannelMask = X5DOT1;
 930         break;
 931     case DevFmtX51Rear:
 932         OutputType.Format.nChannels = 6;
 933         OutputType.dwChannelMask = X5DOT1REAR;
 934         break;
 935     case DevFmtX61:
 936         OutputType.Format.nChannels = 7;
 937         OutputType.dwChannelMask = X6DOT1;
 938         break;
 939     case DevFmtX71:
 940         OutputType.Format.nChannels = 8;
 941         OutputType.dwChannelMask = X7DOT1;
 942         break;
 943     }
 944     switch(mDevice->FmtType)
 945     {
 946     case DevFmtByte:
 947         mDevice->FmtType = DevFmtUByte;
 948         /* fall-through */
 949     case DevFmtUByte:
 950         OutputType.Format.wBitsPerSample = 8;
 951         OutputType.Samples.wValidBitsPerSample = 8;
 952         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 953         break;
 954     case DevFmtUShort:
 955         mDevice->FmtType = DevFmtShort;
 956         /* fall-through */
 957     case DevFmtShort:
 958         OutputType.Format.wBitsPerSample = 16;
 959         OutputType.Samples.wValidBitsPerSample = 16;
 960         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 961         break;
 962     case DevFmtUInt:
 963         mDevice->FmtType = DevFmtInt;
 964         /* fall-through */
 965     case DevFmtInt:
 966         OutputType.Format.wBitsPerSample = 32;
 967         OutputType.Samples.wValidBitsPerSample = 32;
 968         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 969         break;
 970     case DevFmtFloat:
 971         OutputType.Format.wBitsPerSample = 32;
 972         OutputType.Samples.wValidBitsPerSample = 32;
 973         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 974         break;
 975     }
 976     OutputType.Format.nSamplesPerSec = mDevice->Frequency;
 977
 978     OutputType.Format.nBlockAlign = static_cast<WORD>(OutputType.Format.nChannels *
 979         OutputType.Format.wBitsPerSample / 8);
 980     OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
 981         OutputType.Format.nBlockAlign;
 982
 983     TraceFormat("Requesting playback format", &OutputType.Format);
 984     hr = mClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
 985     if(FAILED(hr))
 986     {
 987         ERR("Failed to check format support: 0x%08lx\n", hr);
 988         hr = mClient->GetMixFormat(&wfx);
 989     }
 990     if(FAILED(hr))
 991     {
 992         ERR("Failed to find a supported format: 0x%08lx\n", hr);
 993         return hr;
 994     }
 995
 996     if(wfx != nullptr)
 997     {
 998         TraceFormat("Got playback format", wfx);
 999         if(!MakeExtensible(&OutputType, wfx))
1000         {
1001             CoTaskMemFree(wfx);
1002             return E_FAIL;
1003         }
1004         CoTaskMemFree(wfx);
1005         wfx = nullptr;
1006
1007         mDevice->Frequency = OutputType.Format.nSamplesPerSec;
1008         const uint32_t chancount{OutputType.Format.nChannels};
1009         const DWORD chanmask{OutputType.dwChannelMask};
1010         if(chancount >= 8 && (chanmask&X71Mask) == X7DOT1)
1011             mDevice->FmtChans = DevFmtX71;
1012         else if(chancount >= 7 && (chanmask&X61Mask) == X6DOT1)
1013             mDevice->FmtChans = DevFmtX61;
1014         else if(chancount >= 6 && (chanmask&X51Mask) == X5DOT1)
1015             mDevice->FmtChans = DevFmtX51;
1016         else if(chancount >= 6 && (chanmask&X51RearMask) == X5DOT1REAR)
1017             mDevice->FmtChans = DevFmtX51Rear;
1018         else if(chancount >= 4 && (chanmask&QuadMask) == QUAD)
1019             mDevice->FmtChans = DevFmtQuad;
1020         else if(chancount >= 2 && (chanmask&StereoMask) == STEREO)
1021             mDevice->FmtChans = DevFmtStereo;
1022         else if(chancount >= 1 && (chanmask&MonoMask) == MONO)
1023             mDevice->FmtChans = DevFmtMono;
1024         else
1025         {
1026             ERR("Unhandled extensible channels: %d -- 0x%08lx\n", OutputType.Format.nChannels,
1027                 OutputType.dwChannelMask);
1028             mDevice->FmtChans = DevFmtStereo;
1029             OutputType.Format.nChannels = 2;
1030             OutputType.dwChannelMask = STEREO;
1031         }
1032
1033         if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_PCM))
1034         {
1035             if(OutputType.Format.wBitsPerSample == 8)
1036                 mDevice->FmtType = DevFmtUByte;
1037             else if(OutputType.Format.wBitsPerSample == 16)
1038                 mDevice->FmtType = DevFmtShort;
1039             else if(OutputType.Format.wBitsPerSample == 32)
1040                 mDevice->FmtType = DevFmtInt;
1041             else
1042             {
1043                 mDevice->FmtType = DevFmtShort;
1044                 OutputType.Format.wBitsPerSample = 16;
1045             }
1046         }
1047         else if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
1048         {
1049             mDevice->FmtType = DevFmtFloat;
1050             OutputType.Format.wBitsPerSample = 32;
1051         }
1052         else
1053         {
1054             ERR("Unhandled format sub-type: %s\n", GuidPrinter{OutputType.SubFormat}.c_str());
1055             mDevice->FmtType = DevFmtShort;
1056             if(OutputType.Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE)
1057                 OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
1058             OutputType.Format.wBitsPerSample = 16;
1059             OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1060         }
1061         OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
1062     }
1063     mFrameStep = OutputType.Format.nChannels;
1064
1065     EndpointFormFactor formfactor{UnknownFormFactor};
1066     get_device_formfactor(mMMDev, &formfactor);
1067     mDevice->IsHeadphones = (mDevice->FmtChans == DevFmtStereo
1068         && (formfactor == Headphones || formfactor == Headset));
1069
1070     setChannelOrderFromWFXMask(OutputType.dwChannelMask);
1071
1072     hr = mClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
1073         buf_time.count(), 0, &OutputType.Format, nullptr);
1074     if(FAILED(hr))
1075     {
1076         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
1077         return hr;
1078     }
1079
1080     UINT32 buffer_len{};
1081     ReferenceTime min_per{};
1082     hr = mClient->GetDevicePeriod(&reinterpret_cast<REFERENCE_TIME&>(min_per), nullptr);
1083     if(SUCCEEDED(hr))
1084         hr = mClient->GetBufferSize(&buffer_len);
1085     if(FAILED(hr))
1086     {
1087         ERR("Failed to get audio buffer info: 0x%08lx\n", hr);
1088         return hr;
1089     }
1090
1091     /* Find the nearest multiple of the period size to the update size */
1092     if(min_per < per_time)
1093         min_per *= maxi64((per_time + min_per/2) / min_per, 1);
1094     mDevice->UpdateSize = minu(RefTime2Samples(min_per, mDevice->Frequency), buffer_len/2);
1095     mDevice->BufferSize = buffer_len;
1096
1097     hr = mClient->SetEventHandle(mNotifyEvent);
1098     if(FAILED(hr))
1099     {
1100         ERR("Failed to set event handle: 0x%08lx\n", hr);
1101         return hr;
1102     }
1103
1104     return hr;
1105 }
1106
1107
1108 void WasapiPlayback::start()
1109 {
1110     const HRESULT hr{pushMessage(MsgType::StartDevice).get()};
1111     if(FAILED(hr))
1112         throw al::backend_exception{ALC_INVALID_DEVICE, "Failed to start playback: 0x%lx", hr};
1113 }
1114
1115 HRESULT WasapiPlayback::startProxy()
1116 {
1117     ResetEvent(mNotifyEvent);
1118
1119     HRESULT hr = mClient->Start();
1120     if(FAILED(hr))
1121     {
1122         ERR("Failed to start audio client: 0x%08lx\n", hr);
1123         return hr;
1124     }
1125
1126     void *ptr;
1127     hr = mClient->GetService(IID_IAudioRenderClient, &ptr);
1128     if(SUCCEEDED(hr))
1129     {
1130         mRender = static_cast<IAudioRenderClient*>(ptr);
1131         try {
1132             mKillNow.store(false, std::memory_order_release);
1133             mThread = std::thread{std::mem_fn(&WasapiPlayback::mixerProc), this};
1134         }
1135         catch(...) {
1136             mRender->Release();
1137             mRender = nullptr;
1138             ERR("Failed to start thread\n");
1139             hr = E_FAIL;
1140         }
1141     }
1142
1143     if(FAILED(hr))
1144         mClient->Stop();
1145
1146     return hr;
1147 }
1148
1149
1150 void WasapiPlayback::stop()
1151 { pushMessage(MsgType::StopDevice).wait(); }
1152
1153 void WasapiPlayback::stopProxy()
1154 {
1155     if(!mRender || !mThread.joinable())
1156         return;
1157
1158     mKillNow.store(true, std::memory_order_release);
1159     mThread.join();
1160
1161     mRender->Release();
1162     mRender = nullptr;
1163     mClient->Stop();
1164 }
1165
1166
1167 ClockLatency WasapiPlayback::getClockLatency()
1168 {
1169     ClockLatency ret;
1170
1171     std::lock_guard<std::mutex> _{mMutex};
1172     ret.ClockTime = GetDeviceClockTime(mDevice);
1173     ret.Latency  = std::chrono::seconds{mPadding.load(std::memory_order_relaxed)};
1174     ret.Latency /= mDevice->Frequency;
1175
1176     return ret;
1177 }
1178
1179
1180 struct WasapiCapture final : public BackendBase, WasapiProxy {
1181     WasapiCapture(ALCdevice *device) noexcept : BackendBase{device} { }
1182     ~WasapiCapture() override;
1183
1184     int recordProc();
1185
1186     void open(const ALCchar *name) override;
1187     HRESULT openProxy() override;
1188     void closeProxy() override;
1189
1190     HRESULT resetProxy() override;
1191     void start() override;
1192     HRESULT startProxy() override;
1193     void stop() override;
1194     void stopProxy() override;
1195
1196     ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
1197     ALCuint availableSamples() override;
1198
1199     std::wstring mDevId;
1200
1201     HRESULT mOpenStatus{E_FAIL};
1202     IMMDevice *mMMDev{nullptr};
1203     IAudioClient *mClient{nullptr};
1204     IAudioCaptureClient *mCapture{nullptr};
1205     HANDLE mNotifyEvent{nullptr};
1206
1207     ChannelConverter mChannelConv{};
1208     SampleConverterPtr mSampleConv;
1209     RingBufferPtr mRing;
1210
1211     std::atomic<bool> mKillNow{true};
1212     std::thread mThread;
1213
1214     DEF_NEWDEL(WasapiCapture)
1215 };
1216
1217 WasapiCapture::~WasapiCapture()
1218 {
1219     if(SUCCEEDED(mOpenStatus))
1220         pushMessage(MsgType::CloseDevice).wait();
1221     mOpenStatus = E_FAIL;
1222
1223     if(mNotifyEvent != nullptr)
1224         CloseHandle(mNotifyEvent);
1225     mNotifyEvent = nullptr;
1226 }
1227
1228
1229 FORCE_ALIGN int WasapiCapture::recordProc()
1230 {
1231     HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
1232     if(FAILED(hr))
1233     {
1234         ERR("CoInitializeEx(nullptr, COINIT_MULTITHREADED) failed: 0x%08lx\n", hr);
1235         mDevice->handleDisconnect("COM init failed: 0x%08lx", hr);
1236         return 1;
1237     }
1238
1239     althrd_setname(RECORD_THREAD_NAME);
1240
1241     al::vector<float> samples;
1242     while(!mKillNow.load(std::memory_order_relaxed))
1243     {
1244         UINT32 avail;
1245         hr = mCapture->GetNextPacketSize(&avail);
1246         if(FAILED(hr))
1247             ERR("Failed to get next packet size: 0x%08lx\n", hr);
1248         else if(avail > 0)
1249         {
1250             UINT32 numsamples;
1251             DWORD flags;
1252             BYTE *rdata;
1253
1254             hr = mCapture->GetBuffer(&rdata, &numsamples, &flags, nullptr, nullptr);
1255             if(FAILED(hr))
1256                 ERR("Failed to get capture buffer: 0x%08lx\n", hr);
1257             else
1258             {
1259                 if(mChannelConv.is_active())
1260                 {
1261                     samples.resize(numsamples*2);
1262                     mChannelConv.convert(rdata, samples.data(), numsamples);
1263                     rdata = reinterpret_cast<BYTE*>(samples.data());
1264                 }
1265
1266                 auto data = mRing->getWriteVector();
1267
1268                 size_t dstframes;
1269                 if(mSampleConv)
1270                 {
1271                     const void *srcdata{rdata};
1272                     ALuint srcframes{numsamples};
1273
1274                     dstframes = mSampleConv->convert(&srcdata, &srcframes, data.first.buf,
1275                         static_cast<ALuint>(minz(data.first.len, INT_MAX)));
1276                     if(srcframes > 0 && dstframes == data.first.len && data.second.len > 0)
1277                     {
1278                         /* If some source samples remain, all of the first dest
1279                          * block was filled, and there's space in the second
1280                          * dest block, do another run for the second block.
1281                          */
1282                         dstframes += mSampleConv->convert(&srcdata, &srcframes, data.second.buf,
1283                             static_cast<ALuint>(minz(data.second.len, INT_MAX)));
1284                     }
1285                 }
1286                 else
1287                 {
1288                     const auto framesize = static_cast<ALuint>(mDevice->frameSizeFromFmt());
1289                     size_t len1{minz(data.first.len, numsamples)};
1290                     size_t len2{minz(data.second.len, numsamples-len1)};
1291
1292                     memcpy(data.first.buf, rdata, len1*framesize);
1293                     if(len2 > 0)
1294                         memcpy(data.second.buf, rdata+len1*framesize, len2*framesize);
1295                     dstframes = len1 + len2;
1296                 }
1297
1298                 mRing->writeAdvance(dstframes);
1299
1300                 hr = mCapture->ReleaseBuffer(numsamples);
1301                 if(FAILED(hr)) ERR("Failed to release capture buffer: 0x%08lx\n", hr);
1302             }
1303         }
1304
1305         if(FAILED(hr))
1306         {
1307             mDevice->handleDisconnect("Failed to capture samples: 0x%08lx", hr);
1308             break;
1309         }
1310
1311         DWORD res{WaitForSingleObjectEx(mNotifyEvent, 2000, FALSE)};
1312         if(res != WAIT_OBJECT_0)
1313             ERR("WaitForSingleObjectEx error: 0x%lx\n", res);
1314     }
1315
1316     CoUninitialize();
1317     return 0;
1318 }
1319
1320
1321 void WasapiCapture::open(const ALCchar *name)
1322 {
1323     HRESULT hr{S_OK};
1324
1325     mNotifyEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
1326     if(mNotifyEvent == nullptr)
1327     {
1328         ERR("Failed to create notify event: %lu\n", GetLastError());
1329         hr = E_FAIL;
1330     }
1331
1332     if(SUCCEEDED(hr))
1333     {
1334         if(name)
1335         {
1336             if(CaptureDevices.empty())
1337                 pushMessage(MsgType::EnumerateCapture).wait();
1338
1339             hr = E_FAIL;
1340             auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
1341                 [name](const DevMap &entry) -> bool
1342                 { return entry.name == name || entry.endpoint_guid == name; }
1343             );
1344             if(iter == CaptureDevices.cend())
1345             {
1346                 std::wstring wname{utf8_to_wstr(name)};
1347                 iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
1348                     [&wname](const DevMap &entry) -> bool
1349                     { return entry.devid == wname; }
1350                 );
1351             }
1352             if(iter == CaptureDevices.cend())
1353                 WARN("Failed to find device name matching \"%s\"\n", name);
1354             else
1355             {
1356                 mDevId = iter->devid;
1357                 mDevice->DeviceName = iter->name;
1358                 hr = S_OK;
1359             }
1360         }
1361     }
1362
1363     if(SUCCEEDED(hr))
1364         hr = pushMessage(MsgType::OpenDevice).get();
1365     mOpenStatus = hr;
1366
1367     if(FAILED(hr))
1368     {
1369         if(mNotifyEvent != nullptr)
1370             CloseHandle(mNotifyEvent);
1371         mNotifyEvent = nullptr;
1372
1373         mDevId.clear();
1374
1375         throw al::backend_exception{ALC_INVALID_VALUE, "Device init failed: 0x%08lx", hr};
1376     }
1377
1378     hr = pushMessage(MsgType::ResetDevice).get();
1379     if(FAILED(hr))
1380     {
1381         if(hr == E_OUTOFMEMORY)
1382             throw al::backend_exception{ALC_OUT_OF_MEMORY, "Out of memory"};
1383         throw al::backend_exception{ALC_INVALID_VALUE, "Device reset failed"};
1384     }
1385 }
1386
1387 HRESULT WasapiCapture::openProxy()
1388 {
1389     void *ptr;
1390     HRESULT hr{CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_INPROC_SERVER,
1391         IID_IMMDeviceEnumerator, &ptr)};
1392     if(SUCCEEDED(hr))
1393     {
1394         auto Enumerator = static_cast<IMMDeviceEnumerator*>(ptr);
1395         if(mDevId.empty())
1396             hr = Enumerator->GetDefaultAudioEndpoint(eCapture, eMultimedia, &mMMDev);
1397         else
1398             hr = Enumerator->GetDevice(mDevId.c_str(), &mMMDev);
1399         Enumerator->Release();
1400     }
1401     if(SUCCEEDED(hr))
1402         hr = mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr);
1403     if(SUCCEEDED(hr))
1404     {
1405         mClient = static_cast<IAudioClient*>(ptr);
1406         if(mDevice->DeviceName.empty())
1407             mDevice->DeviceName = get_device_name_and_guid(mMMDev).first;
1408     }
1409
1410     if(FAILED(hr))
1411     {
1412         if(mMMDev)
1413             mMMDev->Release();
1414         mMMDev = nullptr;
1415     }
1416
1417     return hr;
1418 }
1419
1420 void WasapiCapture::closeProxy()
1421 {
1422     if(mClient)
1423         mClient->Release();
1424     mClient = nullptr;
1425
1426     if(mMMDev)
1427         mMMDev->Release();
1428     mMMDev = nullptr;
1429 }
1430
1431 HRESULT WasapiCapture::resetProxy()
1432 {
1433     if(mClient)
1434         mClient->Release();
1435     mClient = nullptr;
1436
1437     void *ptr;
1438     HRESULT hr{mMMDev->Activate(IID_IAudioClient, CLSCTX_INPROC_SERVER, nullptr, &ptr)};
1439     if(FAILED(hr))
1440     {
1441         ERR("Failed to reactivate audio client: 0x%08lx\n", hr);
1442         return hr;
1443     }
1444     mClient = static_cast<IAudioClient*>(ptr);
1445
1446     // Make sure buffer is at least 100ms in size
1447     ReferenceTime buf_time{ReferenceTime{seconds{mDevice->BufferSize}} / mDevice->Frequency};
1448     buf_time = std::max(buf_time, ReferenceTime{milliseconds{100}});
1449
1450     WAVEFORMATEXTENSIBLE OutputType{};
1451     OutputType.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
1452     switch(mDevice->FmtChans)
1453     {
1454     case DevFmtMono:
1455         OutputType.Format.nChannels = 1;
1456         OutputType.dwChannelMask = MONO;
1457         break;
1458     case DevFmtStereo:
1459         OutputType.Format.nChannels = 2;
1460         OutputType.dwChannelMask = STEREO;
1461         break;
1462     case DevFmtQuad:
1463         OutputType.Format.nChannels = 4;
1464         OutputType.dwChannelMask = QUAD;
1465         break;
1466     case DevFmtX51:
1467         OutputType.Format.nChannels = 6;
1468         OutputType.dwChannelMask = X5DOT1;
1469         break;
1470     case DevFmtX51Rear:
1471         OutputType.Format.nChannels = 6;
1472         OutputType.dwChannelMask = X5DOT1REAR;
1473         break;
1474     case DevFmtX61:
1475         OutputType.Format.nChannels = 7;
1476         OutputType.dwChannelMask = X6DOT1;
1477         break;
1478     case DevFmtX71:
1479         OutputType.Format.nChannels = 8;
1480         OutputType.dwChannelMask = X7DOT1;
1481         break;
1482
1483     case DevFmtAmbi3D:
1484         return E_FAIL;
1485     }
1486     switch(mDevice->FmtType)
1487     {
1488     /* NOTE: Signedness doesn't matter, the converter will handle it. */
1489     case DevFmtByte:
1490     case DevFmtUByte:
1491         OutputType.Format.wBitsPerSample = 8;
1492         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1493         break;
1494     case DevFmtShort:
1495     case DevFmtUShort:
1496         OutputType.Format.wBitsPerSample = 16;
1497         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1498         break;
1499     case DevFmtInt:
1500     case DevFmtUInt:
1501         OutputType.Format.wBitsPerSample = 32;
1502         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1503         break;
1504     case DevFmtFloat:
1505         OutputType.Format.wBitsPerSample = 32;
1506         OutputType.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1507         break;
1508     }
1509     OutputType.Samples.wValidBitsPerSample = OutputType.Format.wBitsPerSample;
1510     OutputType.Format.nSamplesPerSec = mDevice->Frequency;
1511
1512     OutputType.Format.nBlockAlign = static_cast<WORD>(OutputType.Format.nChannels *
1513         OutputType.Format.wBitsPerSample / 8);
1514     OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec *
1515         OutputType.Format.nBlockAlign;
1516     OutputType.Format.cbSize = sizeof(OutputType) - sizeof(OutputType.Format);
1517
1518     TraceFormat("Requesting capture format", &OutputType.Format);
1519     WAVEFORMATEX *wfx;
1520     hr = mClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &OutputType.Format, &wfx);
1521     if(FAILED(hr))
1522     {
1523         ERR("Failed to check format support: 0x%08lx\n", hr);
1524         return hr;
1525     }
1526
1527     mSampleConv = nullptr;
1528     mChannelConv = {};
1529
1530     if(wfx != nullptr)
1531     {
1532         TraceFormat("Got capture format", wfx);
1533         if(!(wfx->nChannels == OutputType.Format.nChannels ||
1534              (wfx->nChannels == 1 && OutputType.Format.nChannels == 2) ||
1535              (wfx->nChannels == 2 && OutputType.Format.nChannels == 1)))
1536         {
1537             ERR("Failed to get matching format, wanted: %s %s %uhz, got: %d channel%s %d-bit %luhz\n",
1538                 DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
1539                 mDevice->Frequency, wfx->nChannels, (wfx->nChannels==1)?"":"s", wfx->wBitsPerSample,
1540                 wfx->nSamplesPerSec);
1541             CoTaskMemFree(wfx);
1542             return E_FAIL;
1543         }
1544
1545         if(!MakeExtensible(&OutputType, wfx))
1546         {
1547             CoTaskMemFree(wfx);
1548             return E_FAIL;
1549         }
1550         CoTaskMemFree(wfx);
1551         wfx = nullptr;
1552     }
1553
1554     DevFmtType srcType;
1555     if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_PCM))
1556     {
1557         if(OutputType.Format.wBitsPerSample == 8)
1558             srcType = DevFmtUByte;
1559         else if(OutputType.Format.wBitsPerSample == 16)
1560             srcType = DevFmtShort;
1561         else if(OutputType.Format.wBitsPerSample == 32)
1562             srcType = DevFmtInt;
1563         else
1564         {
1565             ERR("Unhandled integer bit depth: %d\n", OutputType.Format.wBitsPerSample);
1566             return E_FAIL;
1567         }
1568     }
1569     else if(IsEqualGUID(OutputType.SubFormat, KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
1570     {
1571         if(OutputType.Format.wBitsPerSample == 32)
1572             srcType = DevFmtFloat;
1573         else
1574         {
1575             ERR("Unhandled float bit depth: %d\n", OutputType.Format.wBitsPerSample);
1576             return E_FAIL;
1577         }
1578     }
1579     else
1580     {
1581         ERR("Unhandled format sub-type: %s\n", GuidPrinter{OutputType.SubFormat}.c_str());
1582         return E_FAIL;
1583     }
1584
1585     if(mDevice->FmtChans == DevFmtMono && OutputType.Format.nChannels == 2)
1586     {
1587         mChannelConv = ChannelConverter{srcType, DevFmtStereo, mDevice->FmtChans};
1588         TRACE("Created %s stereo-to-mono converter\n", DevFmtTypeString(srcType));
1589         /* The channel converter always outputs float, so change the input type
1590          * for the resampler/type-converter.
1591          */
1592         srcType = DevFmtFloat;
1593     }
1594     else if(mDevice->FmtChans == DevFmtStereo && OutputType.Format.nChannels == 1)
1595     {
1596         mChannelConv = ChannelConverter{srcType, DevFmtMono, mDevice->FmtChans};
1597         TRACE("Created %s mono-to-stereo converter\n", DevFmtTypeString(srcType));
1598         srcType = DevFmtFloat;
1599     }
1600
1601     if(mDevice->Frequency != OutputType.Format.nSamplesPerSec || mDevice->FmtType != srcType)
1602     {
1603         mSampleConv = CreateSampleConverter(srcType, mDevice->FmtType, mDevice->channelsFromFmt(),
1604             OutputType.Format.nSamplesPerSec, mDevice->Frequency, Resampler::FastBSinc24);
1605         if(!mSampleConv)
1606         {
1607             ERR("Failed to create converter for %s format, dst: %s %uhz, src: %s %luhz\n",
1608                 DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
1609                 mDevice->Frequency, DevFmtTypeString(srcType), OutputType.Format.nSamplesPerSec);
1610             return E_FAIL;
1611         }
1612         TRACE("Created converter for %s format, dst: %s %uhz, src: %s %luhz\n",
1613             DevFmtChannelsString(mDevice->FmtChans), DevFmtTypeString(mDevice->FmtType),
1614             mDevice->Frequency, DevFmtTypeString(srcType), OutputType.Format.nSamplesPerSec);
1615     }
1616
1617     hr = mClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
1618         buf_time.count(), 0, &OutputType.Format, nullptr);
1619     if(FAILED(hr))
1620     {
1621         ERR("Failed to initialize audio client: 0x%08lx\n", hr);
1622         return hr;
1623     }
1624
1625     UINT32 buffer_len{};
1626     ReferenceTime min_per{};
1627     hr = mClient->GetDevicePeriod(&reinterpret_cast<REFERENCE_TIME&>(min_per), nullptr);
1628     if(SUCCEEDED(hr))
1629         hr = mClient->GetBufferSize(&buffer_len);
1630     if(FAILED(hr))
1631     {
1632         ERR("Failed to get buffer size: 0x%08lx\n", hr);
1633         return hr;
1634     }
1635     mDevice->UpdateSize = RefTime2Samples(min_per, mDevice->Frequency);
1636     mDevice->BufferSize = buffer_len;
1637
1638     mRing = RingBuffer::Create(buffer_len, mDevice->frameSizeFromFmt(), false);
1639
1640     hr = mClient->SetEventHandle(mNotifyEvent);
1641     if(FAILED(hr))
1642     {
1643         ERR("Failed to set event handle: 0x%08lx\n", hr);
1644         return hr;
1645     }
1646
1647     return hr;
1648 }
1649
1650
1651 void WasapiCapture::start()
1652 {
1653     const HRESULT hr{pushMessage(MsgType::StartDevice).get()};
1654     if(FAILED(hr))
1655         throw al::backend_exception{ALC_INVALID_DEVICE, "Failed to start recording: 0x%lx", hr};
1656 }
1657
1658 HRESULT WasapiCapture::startProxy()
1659 {
1660     ResetEvent(mNotifyEvent);
1661
1662     HRESULT hr{mClient->Start()};
1663     if(FAILED(hr))
1664     {
1665         ERR("Failed to start audio client: 0x%08lx\n", hr);
1666         return hr;
1667     }
1668
1669     void *ptr;
1670     hr = mClient->GetService(IID_IAudioCaptureClient, &ptr);
1671     if(SUCCEEDED(hr))
1672     {
1673         mCapture = static_cast<IAudioCaptureClient*>(ptr);
1674         try {
1675             mKillNow.store(false, std::memory_order_release);
1676             mThread = std::thread{std::mem_fn(&WasapiCapture::recordProc), this};
1677         }
1678         catch(...) {
1679             mCapture->Release();
1680             mCapture = nullptr;
1681             ERR("Failed to start thread\n");
1682             hr = E_FAIL;
1683         }
1684     }
1685
1686     if(FAILED(hr))
1687     {
1688         mClient->Stop();
1689         mClient->Reset();
1690     }
1691
1692     return hr;
1693 }
1694
1695
1696 void WasapiCapture::stop()
1697 { pushMessage(MsgType::StopDevice).wait(); }
1698
1699 void WasapiCapture::stopProxy()
1700 {
1701     if(!mCapture || !mThread.joinable())
1702         return;
1703
1704     mKillNow.store(true, std::memory_order_release);
1705     mThread.join();
1706
1707     mCapture->Release();
1708     mCapture = nullptr;
1709     mClient->Stop();
1710     mClient->Reset();
1711 }
1712
1713
1714 ALCuint WasapiCapture::availableSamples()
1715 { return static_cast<ALCuint>(mRing->readSpace()); }
1716
1717 ALCenum WasapiCapture::captureSamples(al::byte *buffer, ALCuint samples)
1718 {
1719     mRing->read(buffer, samples);
1720     return ALC_NO_ERROR;
1721 }
1722
1723 } // namespace
1724
1725
1726 bool WasapiBackendFactory::init()
1727 {
1728     static HRESULT InitResult{E_FAIL};
1729
1730     if(FAILED(InitResult)) try
1731     {
1732         std::promise<HRESULT> promise;
1733         auto future = promise.get_future();
1734
1735         std::thread{&WasapiProxy::messageHandler, &promise}.detach();
1736         InitResult = future.get();
1737     }
1738     catch(...) {
1739     }
1740
1741     return SUCCEEDED(InitResult) ? ALC_TRUE : ALC_FALSE;
1742 }
1743
1744 bool WasapiBackendFactory::querySupport(BackendType type)
1745 { return type == BackendType::Playback || type == BackendType::Capture; }
1746
1747 std::string WasapiBackendFactory::probe(BackendType type)
1748 {
1749     std::string outnames;
1750     auto add_device = [&outnames](const DevMap &entry) -> void
1751     {
1752         /* +1 to also append the null char (to ensure a null-separated list and
1753          * double-null terminated list).
1754          */
1755         outnames.append(entry.name.c_str(), entry.name.length()+1);
1756     };
1757
1758     switch(type)
1759     {
1760     case BackendType::Playback:
1761         WasapiProxy::pushMessageStatic(MsgType::EnumeratePlayback).wait();
1762         std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
1763         break;
1764
1765     case BackendType::Capture:
1766         WasapiProxy::pushMessageStatic(MsgType::EnumerateCapture).wait();
1767         std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
1768         break;
1769     }
1770
1771     return outnames;
1772 }
1773
1774 BackendPtr WasapiBackendFactory::createBackend(ALCdevice *device, BackendType type)
1775 {
1776     if(type == BackendType::Playback)
1777         return BackendPtr{new WasapiPlayback{device}};
1778     if(type == BackendType::Capture)
1779         return BackendPtr{new WasapiCapture{device}};
1780     return nullptr;
1781 }
1782
1783 BackendFactory &WasapiBackendFactory::getFactory()
1784 {
1785     static WasapiBackendFactory factory{};
1786     return factory;
1787 }