audio_driver_wasapi.cpp 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990
  1. /**************************************************************************/
  2. /* audio_driver_wasapi.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #ifdef WASAPI_ENABLED
  31. #include "audio_driver_wasapi.h"
  32. #include "core/config/project_settings.h"
  33. #include "core/os/os.h"
  34. #include <stdint.h> // INT32_MAX
  35. #include <functiondiscoverykeys.h>
  36. // Define IAudioClient3 if not already defined by MinGW headers
  37. #if defined __MINGW32__ || defined __MINGW64__
  38. #ifndef __IAudioClient3_FWD_DEFINED__
  39. #define __IAudioClient3_FWD_DEFINED__
  40. typedef interface IAudioClient3 IAudioClient3;
  41. #endif // __IAudioClient3_FWD_DEFINED__
  42. #ifndef __IAudioClient3_INTERFACE_DEFINED__
  43. #define __IAudioClient3_INTERFACE_DEFINED__
  44. MIDL_INTERFACE("7ED4EE07-8E67-4CD4-8C1A-2B7A5987AD42")
  45. IAudioClient3 : public IAudioClient2 {
  46. public:
  47. virtual HRESULT STDMETHODCALLTYPE GetSharedModeEnginePeriod(
  48. /* [annotation][in] */
  49. _In_ const WAVEFORMATEX *pFormat,
  50. /* [annotation][out] */
  51. _Out_ UINT32 *pDefaultPeriodInFrames,
  52. /* [annotation][out] */
  53. _Out_ UINT32 *pFundamentalPeriodInFrames,
  54. /* [annotation][out] */
  55. _Out_ UINT32 *pMinPeriodInFrames,
  56. /* [annotation][out] */
  57. _Out_ UINT32 *pMaxPeriodInFrames) = 0;
  58. virtual HRESULT STDMETHODCALLTYPE GetCurrentSharedModeEnginePeriod(
  59. /* [unique][annotation][out] */
  60. _Out_ WAVEFORMATEX * *ppFormat,
  61. /* [annotation][out] */
  62. _Out_ UINT32 * pCurrentPeriodInFrames) = 0;
  63. virtual HRESULT STDMETHODCALLTYPE InitializeSharedAudioStream(
  64. /* [annotation][in] */
  65. _In_ DWORD StreamFlags,
  66. /* [annotation][in] */
  67. _In_ UINT32 PeriodInFrames,
  68. /* [annotation][in] */
  69. _In_ const WAVEFORMATEX *pFormat,
  70. /* [annotation][in] */
  71. _In_opt_ LPCGUID AudioSessionGuid) = 0;
  72. };
  73. __CRT_UUID_DECL(IAudioClient3, 0x7ED4EE07, 0x8E67, 0x4CD4, 0x8C, 0x1A, 0x2B, 0x7A, 0x59, 0x87, 0xAD, 0x42)
  74. #endif // __IAudioClient3_INTERFACE_DEFINED__
  75. #endif // __MINGW32__ || __MINGW64__
  76. #ifndef PKEY_Device_FriendlyName
  77. #undef DEFINE_PROPERTYKEY
  78. /* clang-format off */
  79. #define DEFINE_PROPERTYKEY(id, a, b, c, d, e, f, g, h, i, j, k, l) \
  80. const PROPERTYKEY id = { { a, b, c, { d, e, f, g, h, i, j, k, } }, l };
  81. /* clang-format on */
  82. DEFINE_PROPERTYKEY(PKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 14);
  83. #endif
  84. const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
  85. const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
  86. const IID IID_IAudioClient = __uuidof(IAudioClient);
  87. const IID IID_IAudioClient3 = __uuidof(IAudioClient3);
  88. const IID IID_IAudioRenderClient = __uuidof(IAudioRenderClient);
  89. const IID IID_IAudioCaptureClient = __uuidof(IAudioCaptureClient);
  90. #define SAFE_RELEASE(memory) \
  91. if ((memory) != nullptr) { \
  92. (memory)->Release(); \
  93. (memory) = nullptr; \
  94. }
  95. #define REFTIMES_PER_SEC 10000000
  96. #define REFTIMES_PER_MILLISEC 10000
  97. #define CAPTURE_BUFFER_CHANNELS 2
  98. static bool default_output_device_changed = false;
  99. static bool default_input_device_changed = false;
  100. // Silence warning due to a COM API weirdness (GH-35194).
  101. #if defined(__GNUC__) && !defined(__clang__)
  102. #pragma GCC diagnostic push
  103. #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
  104. #endif
  105. class CMMNotificationClient : public IMMNotificationClient {
  106. LONG _cRef = 1;
  107. IMMDeviceEnumerator *_pEnumerator = nullptr;
  108. public:
  109. CMMNotificationClient() {}
  110. virtual ~CMMNotificationClient() {
  111. if ((_pEnumerator) != nullptr) {
  112. (_pEnumerator)->Release();
  113. (_pEnumerator) = nullptr;
  114. }
  115. }
  116. ULONG STDMETHODCALLTYPE AddRef() {
  117. return InterlockedIncrement(&_cRef);
  118. }
  119. ULONG STDMETHODCALLTYPE Release() {
  120. ULONG ulRef = InterlockedDecrement(&_cRef);
  121. if (0 == ulRef) {
  122. delete this;
  123. }
  124. return ulRef;
  125. }
  126. HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, VOID **ppvInterface) {
  127. if (IID_IUnknown == riid) {
  128. AddRef();
  129. *ppvInterface = (IUnknown *)this;
  130. } else if (__uuidof(IMMNotificationClient) == riid) {
  131. AddRef();
  132. *ppvInterface = (IMMNotificationClient *)this;
  133. } else {
  134. *ppvInterface = nullptr;
  135. return E_NOINTERFACE;
  136. }
  137. return S_OK;
  138. }
  139. HRESULT STDMETHODCALLTYPE OnDeviceAdded(LPCWSTR pwstrDeviceId) {
  140. return S_OK;
  141. }
  142. HRESULT STDMETHODCALLTYPE OnDeviceRemoved(LPCWSTR pwstrDeviceId) {
  143. return S_OK;
  144. }
  145. HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) {
  146. return S_OK;
  147. }
  148. HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDeviceId) {
  149. if (role == eConsole) {
  150. if (flow == eRender) {
  151. default_output_device_changed = true;
  152. } else if (flow == eCapture) {
  153. default_input_device_changed = true;
  154. }
  155. }
  156. return S_OK;
  157. }
  158. HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) {
  159. return S_OK;
  160. }
  161. };
  162. #if defined(__GNUC__) && !defined(__clang__)
  163. #pragma GCC diagnostic pop
  164. #endif
  165. static CMMNotificationClient notif_client;
  166. Error AudioDriverWASAPI::audio_device_init(AudioDeviceWASAPI *p_device, bool p_input, bool p_reinit, bool p_no_audio_client_3) {
  167. WAVEFORMATEX *pwfex;
  168. IMMDeviceEnumerator *enumerator = nullptr;
  169. IMMDevice *output_device = nullptr;
  170. HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void **)&enumerator);
  171. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  172. if (p_device->device_name == "Default") {
  173. hr = enumerator->GetDefaultAudioEndpoint(p_input ? eCapture : eRender, eConsole, &output_device);
  174. } else {
  175. IMMDeviceCollection *devices = nullptr;
  176. hr = enumerator->EnumAudioEndpoints(p_input ? eCapture : eRender, DEVICE_STATE_ACTIVE, &devices);
  177. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  178. LPWSTR strId = nullptr;
  179. bool found = false;
  180. UINT count = 0;
  181. hr = devices->GetCount(&count);
  182. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  183. for (ULONG i = 0; i < count && !found; i++) {
  184. IMMDevice *tmp_device = nullptr;
  185. hr = devices->Item(i, &tmp_device);
  186. ERR_BREAK(hr != S_OK);
  187. IPropertyStore *props = nullptr;
  188. hr = tmp_device->OpenPropertyStore(STGM_READ, &props);
  189. ERR_BREAK(hr != S_OK);
  190. PROPVARIANT propvar;
  191. PropVariantInit(&propvar);
  192. hr = props->GetValue(PKEY_Device_FriendlyName, &propvar);
  193. ERR_BREAK(hr != S_OK);
  194. if (p_device->device_name == String(propvar.pwszVal)) {
  195. hr = tmp_device->GetId(&strId);
  196. ERR_BREAK(hr != S_OK);
  197. found = true;
  198. }
  199. PropVariantClear(&propvar);
  200. props->Release();
  201. tmp_device->Release();
  202. }
  203. if (found) {
  204. hr = enumerator->GetDevice(strId, &output_device);
  205. }
  206. if (strId) {
  207. CoTaskMemFree(strId);
  208. }
  209. if (output_device == nullptr) {
  210. hr = enumerator->GetDefaultAudioEndpoint(p_input ? eCapture : eRender, eConsole, &output_device);
  211. }
  212. }
  213. if (p_reinit) {
  214. // In case we're trying to re-initialize the device, prevent throwing this error on the console,
  215. // otherwise if there is currently no device available this will spam the console.
  216. if (hr != S_OK) {
  217. return ERR_CANT_OPEN;
  218. }
  219. } else {
  220. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  221. }
  222. hr = enumerator->RegisterEndpointNotificationCallback(&notif_client);
  223. SAFE_RELEASE(enumerator)
  224. if (hr != S_OK) {
  225. ERR_PRINT("WASAPI: RegisterEndpointNotificationCallback error");
  226. }
  227. using_audio_client_3 = !p_input; // IID_IAudioClient3 is only used for adjustable output latency (not input)
  228. if (p_no_audio_client_3) {
  229. using_audio_client_3 = false;
  230. }
  231. if (using_audio_client_3) {
  232. hr = output_device->Activate(IID_IAudioClient3, CLSCTX_ALL, nullptr, (void **)&p_device->audio_client);
  233. if (hr != S_OK) {
  234. // IID_IAudioClient3 will never activate on OS versions before Windows 10.
  235. // Older Windows versions should fall back gracefully.
  236. using_audio_client_3 = false;
  237. print_verbose("WASAPI: Couldn't activate output_device with IAudioClient3 interface, falling back to IAudioClient interface");
  238. } else {
  239. print_verbose("WASAPI: Activated output_device using IAudioClient3 interface");
  240. }
  241. }
  242. if (!using_audio_client_3) {
  243. hr = output_device->Activate(IID_IAudioClient, CLSCTX_ALL, nullptr, (void **)&p_device->audio_client);
  244. }
  245. SAFE_RELEASE(output_device)
  246. if (p_reinit) {
  247. if (hr != S_OK) {
  248. return ERR_CANT_OPEN;
  249. }
  250. } else {
  251. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  252. }
  253. if (using_audio_client_3) {
  254. AudioClientProperties audioProps{};
  255. audioProps.cbSize = sizeof(AudioClientProperties);
  256. audioProps.bIsOffload = FALSE;
  257. audioProps.eCategory = AudioCategory_GameEffects;
  258. hr = ((IAudioClient3 *)p_device->audio_client)->SetClientProperties(&audioProps);
  259. ERR_FAIL_COND_V_MSG(hr != S_OK, ERR_CANT_OPEN, "WASAPI: SetClientProperties failed with error 0x" + String::num_uint64(hr, 16) + ".");
  260. }
  261. hr = p_device->audio_client->GetMixFormat(&pwfex);
  262. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  263. print_verbose("WASAPI: wFormatTag = " + itos(pwfex->wFormatTag));
  264. print_verbose("WASAPI: nChannels = " + itos(pwfex->nChannels));
  265. print_verbose("WASAPI: nSamplesPerSec = " + itos(pwfex->nSamplesPerSec));
  266. print_verbose("WASAPI: nAvgBytesPerSec = " + itos(pwfex->nAvgBytesPerSec));
  267. print_verbose("WASAPI: nBlockAlign = " + itos(pwfex->nBlockAlign));
  268. print_verbose("WASAPI: wBitsPerSample = " + itos(pwfex->wBitsPerSample));
  269. print_verbose("WASAPI: cbSize = " + itos(pwfex->cbSize));
  270. WAVEFORMATEX *closest = nullptr;
  271. hr = p_device->audio_client->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, pwfex, &closest);
  272. if (hr == S_FALSE) {
  273. WARN_PRINT("WASAPI: Mix format is not supported by the output_device");
  274. if (closest) {
  275. print_verbose("WASAPI: closest->wFormatTag = " + itos(closest->wFormatTag));
  276. print_verbose("WASAPI: closest->nChannels = " + itos(closest->nChannels));
  277. print_verbose("WASAPI: closest->nSamplesPerSec = " + itos(closest->nSamplesPerSec));
  278. print_verbose("WASAPI: closest->nAvgBytesPerSec = " + itos(closest->nAvgBytesPerSec));
  279. print_verbose("WASAPI: closest->nBlockAlign = " + itos(closest->nBlockAlign));
  280. print_verbose("WASAPI: closest->wBitsPerSample = " + itos(closest->wBitsPerSample));
  281. print_verbose("WASAPI: closest->cbSize = " + itos(closest->cbSize));
  282. WARN_PRINT("WASAPI: Using closest match instead");
  283. pwfex = closest;
  284. }
  285. }
  286. // Since we're using WASAPI Shared Mode we can't control any of these, we just tag along
  287. p_device->channels = pwfex->nChannels;
  288. p_device->format_tag = pwfex->wFormatTag;
  289. p_device->bits_per_sample = pwfex->wBitsPerSample;
  290. p_device->frame_size = (p_device->bits_per_sample / 8) * p_device->channels;
  291. if (p_device->format_tag == WAVE_FORMAT_EXTENSIBLE) {
  292. WAVEFORMATEXTENSIBLE *wfex = (WAVEFORMATEXTENSIBLE *)pwfex;
  293. if (wfex->SubFormat == KSDATAFORMAT_SUBTYPE_PCM) {
  294. p_device->format_tag = WAVE_FORMAT_PCM;
  295. } else if (wfex->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT) {
  296. p_device->format_tag = WAVE_FORMAT_IEEE_FLOAT;
  297. } else {
  298. ERR_PRINT("WASAPI: Format not supported");
  299. ERR_FAIL_V(ERR_CANT_OPEN);
  300. }
  301. } else {
  302. if (p_device->format_tag != WAVE_FORMAT_PCM && p_device->format_tag != WAVE_FORMAT_IEEE_FLOAT) {
  303. ERR_PRINT("WASAPI: Format not supported");
  304. ERR_FAIL_V(ERR_CANT_OPEN);
  305. }
  306. }
  307. if (!using_audio_client_3) {
  308. DWORD streamflags = 0;
  309. if ((DWORD)mix_rate != pwfex->nSamplesPerSec) {
  310. streamflags |= AUDCLNT_STREAMFLAGS_RATEADJUST;
  311. pwfex->nSamplesPerSec = mix_rate;
  312. pwfex->nAvgBytesPerSec = pwfex->nSamplesPerSec * pwfex->nChannels * (pwfex->wBitsPerSample / 8);
  313. }
  314. hr = p_device->audio_client->Initialize(AUDCLNT_SHAREMODE_SHARED, streamflags, p_input ? REFTIMES_PER_SEC : 0, 0, pwfex, nullptr);
  315. ERR_FAIL_COND_V_MSG(hr != S_OK, ERR_CANT_OPEN, "WASAPI: Initialize failed with error 0x" + String::num_uint64(hr, 16) + ".");
  316. UINT32 max_frames;
  317. hr = p_device->audio_client->GetBufferSize(&max_frames);
  318. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  319. // Due to WASAPI Shared Mode we have no control of the buffer size
  320. if (!p_input) {
  321. buffer_frames = max_frames;
  322. int64_t latency = 0;
  323. audio_output.audio_client->GetStreamLatency(&latency);
  324. // WASAPI REFERENCE_TIME units are 100 nanoseconds per unit
  325. // https://docs.microsoft.com/en-us/windows/win32/directshow/reference-time
  326. // Convert REFTIME to seconds as godot uses for latency
  327. real_latency = (float)latency / (float)REFTIMES_PER_SEC;
  328. }
  329. } else {
  330. IAudioClient3 *device_audio_client_3 = (IAudioClient3 *)p_device->audio_client;
  331. // AUDCLNT_STREAMFLAGS_RATEADJUST is an invalid flag with IAudioClient3, therefore we have to use
  332. // the closest supported mix rate supported by the audio driver.
  333. mix_rate = pwfex->nSamplesPerSec;
  334. print_verbose("WASAPI: mix_rate = " + itos(mix_rate));
  335. UINT32 default_period_frames, fundamental_period_frames, min_period_frames, max_period_frames;
  336. hr = device_audio_client_3->GetSharedModeEnginePeriod(
  337. pwfex,
  338. &default_period_frames,
  339. &fundamental_period_frames,
  340. &min_period_frames,
  341. &max_period_frames);
  342. if (hr != S_OK) {
  343. print_verbose("WASAPI: GetSharedModeEnginePeriod failed with error 0x" + String::num_uint64(hr, 16) + ", falling back to IAudioClient.");
  344. CoTaskMemFree(pwfex);
  345. SAFE_RELEASE(output_device)
  346. return audio_device_init(p_device, p_input, p_reinit, true);
  347. }
  348. // Period frames must be an integral multiple of fundamental_period_frames or IAudioClient3 initialization will fail,
  349. // so we need to select the closest multiple to the user-specified latency.
  350. UINT32 desired_period_frames = target_latency_ms * mix_rate / 1000;
  351. UINT32 period_frames = (desired_period_frames / fundamental_period_frames) * fundamental_period_frames;
  352. if (ABS((int64_t)period_frames - (int64_t)desired_period_frames) > ABS((int64_t)(period_frames + fundamental_period_frames) - (int64_t)desired_period_frames)) {
  353. period_frames = period_frames + fundamental_period_frames;
  354. }
  355. period_frames = CLAMP(period_frames, min_period_frames, max_period_frames);
  356. print_verbose("WASAPI: fundamental_period_frames = " + itos(fundamental_period_frames));
  357. print_verbose("WASAPI: min_period_frames = " + itos(min_period_frames));
  358. print_verbose("WASAPI: max_period_frames = " + itos(max_period_frames));
  359. print_verbose("WASAPI: selected a period frame size of " + itos(period_frames));
  360. buffer_frames = period_frames;
  361. hr = device_audio_client_3->InitializeSharedAudioStream(0, period_frames, pwfex, nullptr);
  362. if (hr != S_OK) {
  363. print_verbose("WASAPI: InitializeSharedAudioStream failed with error 0x" + String::num_uint64(hr, 16) + ", falling back to IAudioClient.");
  364. CoTaskMemFree(pwfex);
  365. SAFE_RELEASE(output_device);
  366. return audio_device_init(p_device, p_input, p_reinit, true);
  367. } else {
  368. uint32_t output_latency_in_frames;
  369. WAVEFORMATEX *current_pwfex;
  370. hr = device_audio_client_3->GetCurrentSharedModeEnginePeriod(&current_pwfex, &output_latency_in_frames);
  371. if (hr == OK) {
  372. real_latency = (float)output_latency_in_frames / (float)current_pwfex->nSamplesPerSec;
  373. CoTaskMemFree(current_pwfex);
  374. } else {
  375. print_verbose("WASAPI: GetCurrentSharedModeEnginePeriod failed with error 0x" + String::num_uint64(hr, 16) + ", falling back to IAudioClient.");
  376. CoTaskMemFree(pwfex);
  377. SAFE_RELEASE(output_device);
  378. return audio_device_init(p_device, p_input, p_reinit, true);
  379. }
  380. }
  381. }
  382. if (p_input) {
  383. hr = p_device->audio_client->GetService(IID_IAudioCaptureClient, (void **)&p_device->capture_client);
  384. } else {
  385. hr = p_device->audio_client->GetService(IID_IAudioRenderClient, (void **)&p_device->render_client);
  386. }
  387. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  388. // Free memory
  389. CoTaskMemFree(pwfex);
  390. SAFE_RELEASE(output_device)
  391. return OK;
  392. }
  393. Error AudioDriverWASAPI::init_output_device(bool p_reinit) {
  394. Error err = audio_device_init(&audio_output, false, p_reinit);
  395. if (err != OK) {
  396. return err;
  397. }
  398. switch (audio_output.channels) {
  399. case 2: // Stereo
  400. case 4: // Surround 3.1
  401. case 6: // Surround 5.1
  402. case 8: // Surround 7.1
  403. channels = audio_output.channels;
  404. break;
  405. default:
  406. WARN_PRINT("WASAPI: Unsupported number of channels: " + itos(audio_output.channels));
  407. channels = 2;
  408. break;
  409. }
  410. // Sample rate is independent of channels (ref: https://stackoverflow.com/questions/11048825/audio-sample-frequency-rely-on-channels)
  411. samples_in.resize(buffer_frames * channels);
  412. input_position = 0;
  413. input_size = 0;
  414. print_verbose("WASAPI: detected " + itos(channels) + " channels");
  415. print_verbose("WASAPI: audio buffer frames: " + itos(buffer_frames) + " calculated latency: " + itos(buffer_frames * 1000 / mix_rate) + "ms");
  416. return OK;
  417. }
  418. Error AudioDriverWASAPI::init_input_device(bool p_reinit) {
  419. Error err = audio_device_init(&audio_input, true, p_reinit);
  420. if (err != OK) {
  421. return err;
  422. }
  423. // Get the max frames
  424. UINT32 max_frames;
  425. HRESULT hr = audio_input.audio_client->GetBufferSize(&max_frames);
  426. ERR_FAIL_COND_V(hr != S_OK, ERR_CANT_OPEN);
  427. input_buffer_init(max_frames);
  428. return OK;
  429. }
  430. Error AudioDriverWASAPI::audio_device_finish(AudioDeviceWASAPI *p_device) {
  431. if (p_device->active.is_set()) {
  432. if (p_device->audio_client) {
  433. p_device->audio_client->Stop();
  434. }
  435. p_device->active.clear();
  436. }
  437. SAFE_RELEASE(p_device->audio_client)
  438. SAFE_RELEASE(p_device->render_client)
  439. SAFE_RELEASE(p_device->capture_client)
  440. return OK;
  441. }
  442. Error AudioDriverWASAPI::finish_output_device() {
  443. return audio_device_finish(&audio_output);
  444. }
  445. Error AudioDriverWASAPI::finish_input_device() {
  446. return audio_device_finish(&audio_input);
  447. }
  448. Error AudioDriverWASAPI::init() {
  449. mix_rate = _get_configured_mix_rate();
  450. target_latency_ms = GLOBAL_GET("audio/driver/output_latency");
  451. Error err = init_output_device();
  452. if (err != OK) {
  453. ERR_PRINT("WASAPI: init_output_device error");
  454. }
  455. exit_thread.clear();
  456. thread.start(thread_func, this);
  457. return OK;
  458. }
  459. int AudioDriverWASAPI::get_mix_rate() const {
  460. return mix_rate;
  461. }
  462. float AudioDriverWASAPI::get_latency() {
  463. return real_latency;
  464. }
  465. AudioDriver::SpeakerMode AudioDriverWASAPI::get_speaker_mode() const {
  466. return get_speaker_mode_by_total_channels(channels);
  467. }
  468. PackedStringArray AudioDriverWASAPI::audio_device_get_list(bool p_input) {
  469. PackedStringArray list;
  470. IMMDeviceCollection *devices = nullptr;
  471. IMMDeviceEnumerator *enumerator = nullptr;
  472. list.push_back(String("Default"));
  473. HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void **)&enumerator);
  474. ERR_FAIL_COND_V(hr != S_OK, PackedStringArray());
  475. hr = enumerator->EnumAudioEndpoints(p_input ? eCapture : eRender, DEVICE_STATE_ACTIVE, &devices);
  476. ERR_FAIL_COND_V(hr != S_OK, PackedStringArray());
  477. UINT count = 0;
  478. hr = devices->GetCount(&count);
  479. ERR_FAIL_COND_V(hr != S_OK, PackedStringArray());
  480. for (ULONG i = 0; i < count; i++) {
  481. IMMDevice *output_device = nullptr;
  482. hr = devices->Item(i, &output_device);
  483. ERR_BREAK(hr != S_OK);
  484. IPropertyStore *props = nullptr;
  485. hr = output_device->OpenPropertyStore(STGM_READ, &props);
  486. ERR_BREAK(hr != S_OK);
  487. PROPVARIANT propvar;
  488. PropVariantInit(&propvar);
  489. hr = props->GetValue(PKEY_Device_FriendlyName, &propvar);
  490. ERR_BREAK(hr != S_OK);
  491. list.push_back(String(propvar.pwszVal));
  492. PropVariantClear(&propvar);
  493. props->Release();
  494. output_device->Release();
  495. }
  496. devices->Release();
  497. enumerator->Release();
  498. return list;
  499. }
  500. PackedStringArray AudioDriverWASAPI::get_output_device_list() {
  501. return audio_device_get_list(false);
  502. }
  503. String AudioDriverWASAPI::get_output_device() {
  504. lock();
  505. String name = audio_output.device_name;
  506. unlock();
  507. return name;
  508. }
  509. void AudioDriverWASAPI::set_output_device(const String &p_name) {
  510. lock();
  511. audio_output.new_device = p_name;
  512. unlock();
  513. }
  514. int32_t AudioDriverWASAPI::read_sample(WORD format_tag, int bits_per_sample, BYTE *buffer, int i) {
  515. if (format_tag == WAVE_FORMAT_PCM) {
  516. int32_t sample = 0;
  517. switch (bits_per_sample) {
  518. case 8:
  519. sample = int32_t(((int8_t *)buffer)[i]) << 24;
  520. break;
  521. case 16:
  522. sample = int32_t(((int16_t *)buffer)[i]) << 16;
  523. break;
  524. case 24:
  525. sample |= int32_t(((int8_t *)buffer)[i * 3 + 2]) << 24;
  526. sample |= int32_t(((int8_t *)buffer)[i * 3 + 1]) << 16;
  527. sample |= int32_t(((int8_t *)buffer)[i * 3 + 0]) << 8;
  528. break;
  529. case 32:
  530. sample = ((int32_t *)buffer)[i];
  531. break;
  532. }
  533. return sample;
  534. } else if (format_tag == WAVE_FORMAT_IEEE_FLOAT) {
  535. return int32_t(((float *)buffer)[i] * 32768.0) << 16;
  536. } else {
  537. ERR_PRINT("WASAPI: Unknown format tag");
  538. }
  539. return 0;
  540. }
  541. void AudioDriverWASAPI::write_sample(WORD format_tag, int bits_per_sample, BYTE *buffer, int i, int32_t sample) {
  542. if (format_tag == WAVE_FORMAT_PCM) {
  543. switch (bits_per_sample) {
  544. case 8:
  545. ((int8_t *)buffer)[i] = sample >> 24;
  546. break;
  547. case 16:
  548. ((int16_t *)buffer)[i] = sample >> 16;
  549. break;
  550. case 24:
  551. ((int8_t *)buffer)[i * 3 + 2] = sample >> 24;
  552. ((int8_t *)buffer)[i * 3 + 1] = sample >> 16;
  553. ((int8_t *)buffer)[i * 3 + 0] = sample >> 8;
  554. break;
  555. case 32:
  556. ((int32_t *)buffer)[i] = sample;
  557. break;
  558. }
  559. } else if (format_tag == WAVE_FORMAT_IEEE_FLOAT) {
  560. ((float *)buffer)[i] = (sample >> 16) / 32768.f;
  561. } else {
  562. ERR_PRINT("WASAPI: Unknown format tag");
  563. }
  564. }
  565. void AudioDriverWASAPI::thread_func(void *p_udata) {
  566. CoInitializeEx(nullptr, COINIT_MULTITHREADED);
  567. AudioDriverWASAPI *ad = static_cast<AudioDriverWASAPI *>(p_udata);
  568. uint32_t avail_frames = 0;
  569. uint32_t write_ofs = 0;
  570. while (!ad->exit_thread.is_set()) {
  571. uint32_t read_frames = 0;
  572. uint32_t written_frames = 0;
  573. if (avail_frames == 0) {
  574. ad->lock();
  575. ad->start_counting_ticks();
  576. if (ad->audio_output.active.is_set()) {
  577. ad->audio_server_process(ad->buffer_frames, ad->samples_in.ptrw());
  578. } else {
  579. for (int i = 0; i < ad->samples_in.size(); i++) {
  580. ad->samples_in.write[i] = 0;
  581. }
  582. }
  583. avail_frames = ad->buffer_frames;
  584. write_ofs = 0;
  585. ad->stop_counting_ticks();
  586. ad->unlock();
  587. }
  588. ad->lock();
  589. ad->start_counting_ticks();
  590. if (avail_frames > 0 && ad->audio_output.audio_client) {
  591. UINT32 cur_frames;
  592. bool invalidated = false;
  593. HRESULT hr = ad->audio_output.audio_client->GetCurrentPadding(&cur_frames);
  594. if (hr == S_OK) {
  595. // Check how much frames are available on the WASAPI buffer
  596. UINT32 write_frames = MIN(ad->buffer_frames - cur_frames, avail_frames);
  597. if (write_frames > 0) {
  598. BYTE *buffer = nullptr;
  599. hr = ad->audio_output.render_client->GetBuffer(write_frames, &buffer);
  600. if (hr == S_OK) {
  601. // We're using WASAPI Shared Mode so we must convert the buffer
  602. if (ad->channels == ad->audio_output.channels) {
  603. for (unsigned int i = 0; i < write_frames * ad->channels; i++) {
  604. ad->write_sample(ad->audio_output.format_tag, ad->audio_output.bits_per_sample, buffer, i, ad->samples_in.write[write_ofs++]);
  605. }
  606. } else {
  607. for (unsigned int i = 0; i < write_frames; i++) {
  608. for (unsigned int j = 0; j < MIN(ad->channels, ad->audio_output.channels); j++) {
  609. ad->write_sample(ad->audio_output.format_tag, ad->audio_output.bits_per_sample, buffer, i * ad->audio_output.channels + j, ad->samples_in.write[write_ofs++]);
  610. }
  611. if (ad->audio_output.channels > ad->channels) {
  612. for (unsigned int j = ad->channels; j < ad->audio_output.channels; j++) {
  613. ad->write_sample(ad->audio_output.format_tag, ad->audio_output.bits_per_sample, buffer, i * ad->audio_output.channels + j, 0);
  614. }
  615. }
  616. }
  617. }
  618. hr = ad->audio_output.render_client->ReleaseBuffer(write_frames, 0);
  619. if (hr != S_OK) {
  620. ERR_PRINT("WASAPI: Release buffer error");
  621. }
  622. avail_frames -= write_frames;
  623. written_frames += write_frames;
  624. } else if (hr == AUDCLNT_E_DEVICE_INVALIDATED) {
  625. // output_device is not valid anymore, reopen it
  626. Error err = ad->finish_output_device();
  627. if (err != OK) {
  628. ERR_PRINT("WASAPI: finish_output_device error");
  629. } else {
  630. // We reopened the output device and samples_in may have resized, so invalidate the current avail_frames
  631. avail_frames = 0;
  632. }
  633. } else {
  634. ERR_PRINT("WASAPI: Get buffer error");
  635. ad->exit_thread.set();
  636. }
  637. }
  638. } else if (hr == AUDCLNT_E_DEVICE_INVALIDATED) {
  639. invalidated = true;
  640. } else {
  641. ERR_PRINT("WASAPI: GetCurrentPadding error");
  642. }
  643. if (invalidated) {
  644. // output_device is not valid anymore
  645. WARN_PRINT("WASAPI: Current output_device invalidated, closing output_device");
  646. Error err = ad->finish_output_device();
  647. if (err != OK) {
  648. ERR_PRINT("WASAPI: finish_output_device error");
  649. }
  650. }
  651. }
  652. // If we're using the Default output device and it changed finish it so we'll re-init the output device
  653. if (ad->audio_output.device_name == "Default" && default_output_device_changed) {
  654. Error err = ad->finish_output_device();
  655. if (err != OK) {
  656. ERR_PRINT("WASAPI: finish_output_device error");
  657. }
  658. default_output_device_changed = false;
  659. }
  660. // User selected a new output device, finish the current one so we'll init the new output device
  661. if (ad->audio_output.device_name != ad->audio_output.new_device) {
  662. ad->audio_output.device_name = ad->audio_output.new_device;
  663. Error err = ad->finish_output_device();
  664. if (err != OK) {
  665. ERR_PRINT("WASAPI: finish_output_device error");
  666. }
  667. }
  668. if (!ad->audio_output.audio_client) {
  669. Error err = ad->init_output_device(true);
  670. if (err == OK) {
  671. ad->start();
  672. }
  673. avail_frames = 0;
  674. write_ofs = 0;
  675. }
  676. if (ad->audio_input.active.is_set()) {
  677. UINT32 packet_length = 0;
  678. BYTE *data;
  679. UINT32 num_frames_available;
  680. DWORD flags;
  681. HRESULT hr = ad->audio_input.capture_client->GetNextPacketSize(&packet_length);
  682. if (hr == S_OK) {
  683. while (packet_length != 0) {
  684. hr = ad->audio_input.capture_client->GetBuffer(&data, &num_frames_available, &flags, nullptr, nullptr);
  685. ERR_BREAK(hr != S_OK);
  686. // fixme: Only works for floating point atm
  687. for (UINT32 j = 0; j < num_frames_available; j++) {
  688. int32_t l, r;
  689. if (flags & AUDCLNT_BUFFERFLAGS_SILENT) {
  690. l = r = 0;
  691. } else {
  692. if (ad->audio_input.channels == 2) {
  693. l = read_sample(ad->audio_input.format_tag, ad->audio_input.bits_per_sample, data, j * 2);
  694. r = read_sample(ad->audio_input.format_tag, ad->audio_input.bits_per_sample, data, j * 2 + 1);
  695. } else if (ad->audio_input.channels == 1) {
  696. l = r = read_sample(ad->audio_input.format_tag, ad->audio_input.bits_per_sample, data, j);
  697. } else {
  698. l = r = 0;
  699. ERR_PRINT("WASAPI: unsupported channel count in microphone!");
  700. }
  701. }
  702. ad->input_buffer_write(l);
  703. ad->input_buffer_write(r);
  704. }
  705. read_frames += num_frames_available;
  706. hr = ad->audio_input.capture_client->ReleaseBuffer(num_frames_available);
  707. ERR_BREAK(hr != S_OK);
  708. hr = ad->audio_input.capture_client->GetNextPacketSize(&packet_length);
  709. ERR_BREAK(hr != S_OK);
  710. }
  711. }
  712. // If we're using the Default output device and it changed finish it so we'll re-init the output device
  713. if (ad->audio_input.device_name == "Default" && default_input_device_changed) {
  714. Error err = ad->finish_input_device();
  715. if (err != OK) {
  716. ERR_PRINT("WASAPI: finish_input_device error");
  717. }
  718. default_input_device_changed = false;
  719. }
  720. // User selected a new input device, finish the current one so we'll init the new input device
  721. if (ad->audio_input.device_name != ad->audio_input.new_device) {
  722. ad->audio_input.device_name = ad->audio_input.new_device;
  723. Error err = ad->finish_input_device();
  724. if (err != OK) {
  725. ERR_PRINT("WASAPI: finish_input_device error");
  726. }
  727. }
  728. if (!ad->audio_input.audio_client) {
  729. Error err = ad->init_input_device(true);
  730. if (err == OK) {
  731. ad->input_start();
  732. }
  733. }
  734. }
  735. ad->stop_counting_ticks();
  736. ad->unlock();
  737. // Let the thread rest a while if we haven't read or write anything
  738. if (written_frames == 0 && read_frames == 0) {
  739. OS::get_singleton()->delay_usec(1000);
  740. }
  741. }
  742. CoUninitialize();
  743. }
  744. void AudioDriverWASAPI::start() {
  745. if (audio_output.audio_client) {
  746. HRESULT hr = audio_output.audio_client->Start();
  747. if (hr != S_OK) {
  748. ERR_PRINT("WASAPI: Start failed");
  749. } else {
  750. audio_output.active.set();
  751. }
  752. }
  753. }
  754. void AudioDriverWASAPI::lock() {
  755. mutex.lock();
  756. }
  757. void AudioDriverWASAPI::unlock() {
  758. mutex.unlock();
  759. }
  760. void AudioDriverWASAPI::finish() {
  761. exit_thread.set();
  762. if (thread.is_started()) {
  763. thread.wait_to_finish();
  764. }
  765. finish_input_device();
  766. finish_output_device();
  767. }
  768. Error AudioDriverWASAPI::input_start() {
  769. Error err = init_input_device();
  770. if (err != OK) {
  771. ERR_PRINT("WASAPI: init_input_device error");
  772. return err;
  773. }
  774. if (audio_input.active.is_set()) {
  775. return FAILED;
  776. }
  777. audio_input.audio_client->Start();
  778. audio_input.active.set();
  779. return OK;
  780. }
  781. Error AudioDriverWASAPI::input_stop() {
  782. if (audio_input.active.is_set()) {
  783. audio_input.audio_client->Stop();
  784. audio_input.active.clear();
  785. return OK;
  786. }
  787. return FAILED;
  788. }
  789. PackedStringArray AudioDriverWASAPI::get_input_device_list() {
  790. return audio_device_get_list(true);
  791. }
  792. String AudioDriverWASAPI::get_input_device() {
  793. lock();
  794. String name = audio_input.device_name;
  795. unlock();
  796. return name;
  797. }
  798. void AudioDriverWASAPI::set_input_device(const String &p_name) {
  799. lock();
  800. audio_input.new_device = p_name;
  801. unlock();
  802. }
  803. AudioDriverWASAPI::AudioDriverWASAPI() {
  804. samples_in.clear();
  805. }
  806. #endif // WASAPI_ENABLED