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