?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #26350 from jjd-uk/estuary_media_align
[xbmc.git] / xbmc / cores / AudioEngine / Sinks / AESinkWASAPI.cpp
blobcb9f8d3bb0c1ea06f848c1aa895bea0fed81b2ee
1 /*
2 * Copyright (C) 2010-2018 Team Kodi
3 * This file is part of Kodi - https://kodi.tv
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later
6 * See LICENSES/README.md for more information.
7 */
8
9 #include "AESinkWASAPI.h"
10
11 #include "cores/AudioEngine/AESinkFactory.h"
12 #include "cores/AudioEngine/Utils/AEDeviceInfo.h"
13 #include "cores/AudioEngine/Utils/AEUtil.h"
14 #include "utils/StringUtils.h"
15 #include "utils/SystemInfo.h"
16 #include "utils/TimeUtils.h"
17 #include "utils/XTimeUtils.h"
18 #include "utils/log.h"
19
20 #include "platform/win32/WIN32Util.h"
21
22 #include <algorithm>
23 #include <stdint.h>
24
25 #include <Audioclient.h>
26 #include <Mmreg.h>
27
28 #ifdef TARGET_WINDOWS_DESKTOP
29 # pragma comment(lib, "Avrt.lib")
30 #endif // TARGET_WINDOWS_DESKTOP
31
32 const IID IID_IAudioRenderClient = __uuidof(IAudioRenderClient);
33 const IID IID_IAudioClock = __uuidof(IAudioClock);
34 DEFINE_PROPERTYKEY(PKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 14);
35 DEFINE_PROPERTYKEY(PKEY_Device_EnumeratorName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 24);
36
37 #define EXIT_ON_FAILURE(hr, reason) \
38 if (FAILED(hr)) \
39 { \
40 CLog::LogF(LOGERROR, reason " - error {}", hr, CWIN32Util::FormatHRESULT(hr)); \
41 goto failed; \
42 }
43
44 template<class T>
45 inline void SafeRelease(T **ppT)
46 {
47 if (*ppT)
48 {
49 (*ppT)->Release();
50 *ppT = nullptr;
51 }
52 }
53
54 using namespace Microsoft::WRL;
55
56 CAESinkWASAPI::CAESinkWASAPI()
57 {
58 m_channelLayout.Reset();
59 }
60
61 CAESinkWASAPI::~CAESinkWASAPI()
62 {
63 }
64
65 void CAESinkWASAPI::Register()
66 {
67 AE::AESinkRegEntry reg;
68 reg.sinkName = "WASAPI";
69 reg.createFunc = CAESinkWASAPI::Create;
70 reg.enumerateFunc = CAESinkWASAPI::EnumerateDevicesEx;
71 AE::CAESinkFactory::RegisterSink(reg);
72 }
73
74 std::unique_ptr<IAESink> CAESinkWASAPI::Create(std::string& device, AEAudioFormat& desiredFormat)
75 {
76 auto sink = std::make_unique<CAESinkWASAPI>();
77 if (sink->Initialize(desiredFormat, device))
78 return sink;
79
80 return {};
81 }
82
83 bool CAESinkWASAPI::Initialize(AEAudioFormat &format, std::string &device)
84 {
85 if (m_initialized)
86 return false;
87
88 m_device = device;
89 bool bdefault = false;
90 HRESULT hr = S_FALSE;
91
92 /* Save requested format */
93 /* Clear returned format */
94 sinkReqFormat = format.m_dataFormat;
95 sinkRetFormat = AE_FMT_INVALID;
96
97 if(StringUtils::EndsWithNoCase(device, std::string("default")))
98 bdefault = true;
99
100 if(!bdefault)
101 {
102 hr = CAESinkFactoryWin::ActivateWASAPIDevice(device, &m_pDevice);
103 EXIT_ON_FAILURE(hr, "Retrieval of WASAPI endpoint failed.")
104 }
105
106 if (!m_pDevice)
107 {
108 if(!bdefault)
109 {
110 CLog::LogF(LOGINFO,
111 "Could not locate the device named \"{}\" in the list of WASAPI endpoint devices. "
112 " Trying the default device...",
113 device);
114 }
115
116 std::string defaultId = CAESinkFactoryWin::GetDefaultDeviceId();
117 if (defaultId.empty())
118 {
119 CLog::LogF(LOGINFO, "Could not locate the default device id in the list of WASAPI endpoint devices.");
120 goto failed;
121 }
122
123 hr = CAESinkFactoryWin::ActivateWASAPIDevice(defaultId, &m_pDevice);
124 EXIT_ON_FAILURE(hr, "Could not retrieve the default WASAPI audio endpoint.")
125
126 device = defaultId;
127 }
128
129 hr = m_pDevice->Activate(m_pAudioClient.ReleaseAndGetAddressOf());
130 EXIT_ON_FAILURE(hr, "Activating the WASAPI endpoint device failed.")
131
132 if (!InitializeExclusive(format))
133 {
134 CLog::LogF(LOGINFO, "Could not Initialize Exclusive with that format");
135 goto failed;
136 }
137
138 /* get the buffer size and calculate the frames for AE */
139 m_pAudioClient->GetBufferSize(&m_uiBufferLen);
140
141 format.m_frames = m_uiBufferLen;
142 m_format = format;
143 sinkRetFormat = format.m_dataFormat;
144
145 hr = m_pAudioClient->GetService(IID_IAudioRenderClient, reinterpret_cast<void**>(m_pRenderClient.ReleaseAndGetAddressOf()));
146 EXIT_ON_FAILURE(hr, "Could not initialize the WASAPI render client interface.")
147
148 hr = m_pAudioClient->GetService(IID_IAudioClock, reinterpret_cast<void**>(m_pAudioClock.ReleaseAndGetAddressOf()));
149 EXIT_ON_FAILURE(hr, "Could not initialize the WASAPI audio clock interface.")
150
151 hr = m_pAudioClock->GetFrequency(&m_clockFreq);
152 EXIT_ON_FAILURE(hr, "Retrieval of IAudioClock::GetFrequency failed.")
153
154 m_needDataEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
155 hr = m_pAudioClient->SetEventHandle(m_needDataEvent);
156 EXIT_ON_FAILURE(hr, "Could not set the WASAPI event handler.");
157
158 m_initialized = true;
159 m_isDirty = false;
160
161 // allow feeding less samples than buffer size
162 // if the device is opened exclusive and event driven, provided samples must match buffersize
163 // ActiveAE tries to align provided samples with buffer size but cannot guarantee (e.g. transcoding)
164 // this can be avoided by dropping the event mode which has not much benefit; SoftAE polls anyway
165 m_buffer.resize(format.m_frames * format.m_frameSize);
166 m_bufferPtr = 0;
167
168 return true;
169
170 failed:
171 CLog::LogF(LOGERROR, "WASAPI initialization failed.");
172 SafeRelease(&m_pDevice);
173 if(m_needDataEvent)
174 {
175 CloseHandle(m_needDataEvent);
176 m_needDataEvent = 0;
177 }
178
179 return false;
180 }
181
182 void CAESinkWASAPI::Deinitialize()
183 {
184 if (!m_initialized && !m_isDirty)
185 return;
186
187 if (m_running)
188 {
189 try
190 {
191 m_pAudioClient->Stop(); //stop the audio output
192 m_pAudioClient->Reset(); //flush buffer and reset audio clock stream position
193 m_sinkFrames = 0;
194 }
195 catch (...)
196 {
197 CLog::LogF(LOGDEBUG, "Invalidated AudioClient - Releasing");
198 }
199 }
200 m_running = false;
201
202 CloseHandle(m_needDataEvent);
203
204 m_pRenderClient = nullptr;
205 m_pAudioClient = nullptr;
206 m_pAudioClock = nullptr;
207 SafeRelease(&m_pDevice);
208
209 m_initialized = false;
210
211 m_bufferPtr = 0;
212 }
213
214 /**
215 * @brief rescale uint64_t without overflowing on large values
216 */
217 static uint64_t rescale_u64(uint64_t val, uint64_t num, uint64_t den)
218 {
219 return ((val / den) * num) + (((val % den) * num) / den);
220 }
221
222
223 void CAESinkWASAPI::GetDelay(AEDelayStatus& status)
224 {
225 HRESULT hr;
226 uint64_t pos, tick;
227 int retries = 0;
228
229 if (!m_initialized)
230 goto failed;
231
232 do {
233 hr = m_pAudioClock->GetPosition(&pos, &tick);
234 } while (hr != S_OK && ++retries < 100);
235 EXIT_ON_FAILURE(hr, "Retrieval of IAudioClock::GetPosition failed.")
236
237 status.delay = (double)(m_sinkFrames + m_bufferPtr) / m_format.m_sampleRate - (double)pos / m_clockFreq;
238 status.tick = rescale_u64(tick, CurrentHostFrequency(), 10000000); /* convert from 100ns back to qpc ticks */
239 return;
240 failed:
241 status.SetDelay(0);
242 }
243
244 double CAESinkWASAPI::GetCacheTotal()
245 {
246 if (!m_initialized)
247 return 0.0;
248
249 return m_sinkLatency;
250 }
251
252 unsigned int CAESinkWASAPI::AddPackets(uint8_t **data, unsigned int frames, unsigned int offset)
253 {
254 if (!m_initialized)
255 return 0;
256
257 HRESULT hr;
258 BYTE* buf;
259
260 #ifndef _DEBUG
261 LARGE_INTEGER timerStart;
262 LARGE_INTEGER timerStop;
263 LARGE_INTEGER timerFreq;
264 #endif
265
266 unsigned int NumFramesRequested = m_format.m_frames;
267 unsigned int FramesToCopy = std::min(m_format.m_frames - m_bufferPtr, frames);
268 uint8_t *buffer = data[0]+offset*m_format.m_frameSize;
269 if (m_bufferPtr != 0 || frames != m_format.m_frames)
270 {
271 memcpy(m_buffer.data() + m_bufferPtr * m_format.m_frameSize, buffer,
272 FramesToCopy * m_format.m_frameSize);
273 m_bufferPtr += FramesToCopy;
274 if (m_bufferPtr != m_format.m_frames)
275 return frames;
276 }
277
278 if (!m_running) //first time called, pre-fill buffer then start audio client
279 {
280 hr = m_pAudioClient->Reset();
281 if (FAILED(hr))
282 {
283 CLog::LogF(LOGERROR, " AudioClient reset failed due to {}", CWIN32Util::FormatHRESULT(hr));
284 return 0;
285 }
286 hr = m_pRenderClient->GetBuffer(NumFramesRequested, &buf);
287 if (FAILED(hr))
288 {
289 #ifdef _DEBUG
290 CLog::LogF(LOGERROR, "GetBuffer failed due to {}", CWIN32Util::FormatHRESULT(hr));
291 #endif
292 m_isDirty = true; //flag new device or re-init needed
293 return INT_MAX;
294 }
295
296 hr = m_pRenderClient->ReleaseBuffer(NumFramesRequested,
297 AUDCLNT_BUFFERFLAGS_SILENT); //pass back to audio driver
298 if (FAILED(hr))
299 {
300 #ifdef _DEBUG
301 CLog::LogF(LOGDEBUG, "ReleaseBuffer failed due to {}.", CWIN32Util::FormatHRESULT(hr));
302 #endif
303 m_isDirty = true; //flag new device or re-init needed
304 return INT_MAX;
305 }
306 m_sinkFrames += NumFramesRequested;
307
308 hr = m_pAudioClient->Start(); //start the audio driver running
309 if (FAILED(hr))
310 CLog::LogF(LOGERROR, "AudioClient Start Failed");
311 m_running = true; //signal that we're processing frames
312 return 0U;
313 }
314
315 #ifndef _DEBUG
316 /* Get clock time for latency checks */
317 QueryPerformanceFrequency(&timerFreq);
318 QueryPerformanceCounter(&timerStart);
319 #endif
320
321 /* Wait for Audio Driver to tell us it's got a buffer available */
322 DWORD eventAudioCallback;
323 eventAudioCallback = WaitForSingleObject(m_needDataEvent, 1100);
324
325 if(eventAudioCallback != WAIT_OBJECT_0 || !&buf)
326 {
327 CLog::LogF(LOGERROR, "Endpoint Buffer timed out");
328 return INT_MAX;
329 }
330
331 if (!m_running)
332 return 0;
333
334 #ifndef _DEBUG
335 QueryPerformanceCounter(&timerStop);
336 LONGLONG timerDiff = timerStop.QuadPart - timerStart.QuadPart;
337 double timerElapsed = (double) timerDiff * 1000.0 / (double) timerFreq.QuadPart;
338 m_avgTimeWaiting += (timerElapsed - m_avgTimeWaiting) * 0.5;
339
340 if (m_avgTimeWaiting < 3.0)
341 {
342 CLog::LogF(LOGDEBUG, "Possible AQ Loss: Avg. Time Waiting for Audio Driver callback : {}msec",
343 (int)m_avgTimeWaiting);
344 }
345 #endif
346
347 hr = m_pRenderClient->GetBuffer(NumFramesRequested, &buf);
348 if (FAILED(hr))
349 {
350 #ifdef _DEBUG
351 CLog::LogF(LOGERROR, "GetBuffer failed due to {}", CWIN32Util::FormatHRESULT(hr));
352 #endif
353 return INT_MAX;
354 }
355
356 // fill buffer
357 memcpy(buf, m_bufferPtr == 0 ? buffer : m_buffer.data(),
358 NumFramesRequested * m_format.m_frameSize);
359 m_bufferPtr = 0;
360
361 hr = m_pRenderClient->ReleaseBuffer(NumFramesRequested, 0); //pass back to audio driver
362 if (FAILED(hr))
363 {
364 #ifdef _DEBUG
365 CLog::LogF(LOGDEBUG, "ReleaseBuffer failed due to {}.", CWIN32Util::FormatHRESULT(hr));
366 #endif
367 return INT_MAX;
368 }
369 m_sinkFrames += NumFramesRequested;
370
371 if (FramesToCopy != frames)
372 {
373 m_bufferPtr = frames-FramesToCopy;
374 memcpy(m_buffer.data(), buffer + FramesToCopy * m_format.m_frameSize,
375 m_bufferPtr * m_format.m_frameSize);
376 }
377
378 return frames;
379 }
380
381 void CAESinkWASAPI::EnumerateDevicesEx(AEDeviceInfoList &deviceInfoList, bool force)
382 {
383 CAEDeviceInfo deviceInfo;
384 CAEChannelInfo deviceChannels;
385 bool add192 = false;
386 bool add48 = false;
387
388 WAVEFORMATEXTENSIBLE wfxex = {};
389 HRESULT hr;
390
391 const bool onlyPT = (CSysInfo::GetWindowsDeviceFamily() == CSysInfo::WindowsDeviceFamily::Xbox);
392
393 for(RendererDetail& details : CAESinkFactoryWin::GetRendererDetails())
394 {
395 deviceInfo.m_channels.Reset();
396 deviceInfo.m_dataFormats.clear();
397 deviceInfo.m_sampleRates.clear();
398 deviceInfo.m_streamTypes.clear();
399 deviceChannels.Reset();
400 add192 = false;
401 add48 = false;
402
403 for (unsigned int c = 0; c < WASAPI_SPEAKER_COUNT; c++)
404 {
405 if (details.uiChannelMask & WASAPIChannelOrder[c])
406 deviceChannels += AEChannelNames[c];
407 }
408
409 IAEWASAPIDevice* pDevice;
410 hr = CAESinkFactoryWin::ActivateWASAPIDevice(details.strDeviceId, &pDevice);
411 if (FAILED(hr))
412 {
413 CLog::LogF(LOGERROR, "Retrieval of WASAPI endpoint failed.");
414 goto failed;
415 }
416
417 ComPtr<IAudioClient> pClient = nullptr;
418 hr = pDevice->Activate(pClient.GetAddressOf());
419 if (SUCCEEDED(hr))
420 {
421 /* Test format DTS-HD-HR */
422 wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
423 wfxex.Format.nSamplesPerSec = 192000;
424 wfxex.dwChannelMask = KSAUDIO_SPEAKER_5POINT1;
425 wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
426 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DTS_HD;
427 wfxex.Format.wBitsPerSample = 16;
428 wfxex.Samples.wValidBitsPerSample = 16;
429 wfxex.Format.nChannels = 2;
430 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
431 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
432 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
433 if (hr == AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED)
434 {
435 CLog::LogF(LOGINFO,
436 "Exclusive mode is not allowed on device \"{}\", check device settings.",
437 details.strDescription);
438 SafeRelease(&pDevice);
439 continue;
440 }
441 if (SUCCEEDED(hr) || details.eDeviceType == AE_DEVTYPE_HDMI)
442 {
443 if(FAILED(hr))
444 {
445 CLog::LogF(LOGINFO, "stream type \"{}\" on device \"{}\" seems to be not supported.",
446 CAEUtil::StreamTypeToStr(CAEStreamInfo::STREAM_TYPE_DTSHD),
447 details.strDescription);
448 }
449
450 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD);
451 add192 = true;
452 }
453
454 /* Test format DTS-HD */
455 wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
456 wfxex.Format.nSamplesPerSec = 192000;
457 wfxex.dwChannelMask = KSAUDIO_SPEAKER_7POINT1_SURROUND;
458 wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
459 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DTS_HD;
460 wfxex.Format.wBitsPerSample = 16;
461 wfxex.Samples.wValidBitsPerSample = 16;
462 wfxex.Format.nChannels = 8;
463 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
464 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
465 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
466 if (hr == AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED)
467 {
468 CLog::LogF(LOGINFO,
469 "Exclusive mode is not allowed on device \"{}\", check device settings.",
470 details.strDescription);
471 SafeRelease(&pDevice);
472 continue;
473 }
474 if (SUCCEEDED(hr) || details.eDeviceType == AE_DEVTYPE_HDMI)
475 {
476 if(FAILED(hr))
477 {
478 CLog::LogF(LOGINFO, "stream type \"{}\" on device \"{}\" seems to be not supported.",
479 CAEUtil::StreamTypeToStr(CAEStreamInfo::STREAM_TYPE_DTSHD_MA),
480 details.strDescription);
481 }
482
483 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD_MA);
484 add192 = true;
485 }
486
487 /* Test format Dolby TrueHD */
488 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_MLP;
489 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
490 if (SUCCEEDED(hr) || details.eDeviceType == AE_DEVTYPE_HDMI)
491 {
492 if(FAILED(hr))
493 {
494 CLog::LogF(LOGINFO, "stream type \"{}\" on device \"{}\" seems to be not supported.",
495 CAEUtil::StreamTypeToStr(CAEStreamInfo::STREAM_TYPE_TRUEHD),
496 details.strDescription);
497 }
498
499 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_TRUEHD);
500 add192 = true;
501 }
502
503 /* Test format Dolby EAC3 */
504 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL_PLUS;
505 wfxex.Format.nChannels = 2;
506 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
507 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
508 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
509 if (SUCCEEDED(hr) || details.eDeviceType == AE_DEVTYPE_HDMI)
510 {
511 if(FAILED(hr))
512 {
513 CLog::LogF(LOGINFO, "stream type \"{}\" on device \"{}\" seems to be not supported.",
514 CAEUtil::StreamTypeToStr(CAEStreamInfo::STREAM_TYPE_EAC3),
515 details.strDescription);
516 }
517
518 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_EAC3);
519 add192 = true;
520 }
521
522 /* Test format DTS */
523 wfxex.Format.nSamplesPerSec = 48000;
524 wfxex.dwChannelMask = KSAUDIO_SPEAKER_5POINT1;
525 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DTS;
526 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
527 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
528 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
529 if (SUCCEEDED(hr) || details.eDeviceType == AE_DEVTYPE_HDMI)
530 {
531 if(FAILED(hr))
532 {
533 CLog::LogF(LOGINFO, "stream type \"{}\" on device \"{}\" seems to be not supported.",
534 "STREAM_TYPE_DTS", details.strDescription);
535 }
536
537 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTSHD_CORE);
538 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_2048);
539 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_1024);
540 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_DTS_512);
541 add48 = true;
542 }
543
544 /* Test format Dolby AC3 */
545 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL;
546 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
547 if (SUCCEEDED(hr) || details.eDeviceType == AE_DEVTYPE_HDMI)
548 {
549 if(FAILED(hr))
550 {
551 CLog::LogF(LOGINFO, "stream type \"{}\" on device \"{}\" seems to be not supported.",
552 CAEUtil::StreamTypeToStr(CAEStreamInfo::STREAM_TYPE_AC3),
553 details.strDescription);
554 }
555
556 deviceInfo.m_streamTypes.push_back(CAEStreamInfo::STREAM_TYPE_AC3);
557 add48 = true;
558 }
559
560 /* Test format for PCM format iteration */
561 wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
562 wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO;
563 wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
564 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
565
566 for (int p = AE_FMT_FLOAT; p > AE_FMT_INVALID; p--)
567 {
568 if (p < AE_FMT_FLOAT)
569 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
570 wfxex.Format.wBitsPerSample = CAEUtil::DataFormatToBits((AEDataFormat) p);
571 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
572 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
573 if (p == AE_FMT_S24NE4MSB)
574 {
575 wfxex.Samples.wValidBitsPerSample = 24;
576 }
577 else if (p <= AE_FMT_S24NE4 && p >= AE_FMT_S24BE4)
578 {
579 // not supported
580 continue;
581 }
582 else
583 {
584 wfxex.Samples.wValidBitsPerSample = wfxex.Format.wBitsPerSample;
585 }
586
587 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
588 if (SUCCEEDED(hr))
589 deviceInfo.m_dataFormats.push_back((AEDataFormat) p);
590 }
591
592 /* Test format for sample rate iteration */
593 wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
594 wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO;
595 wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
596 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
597
598 // 16 bits is most widely supported and likely to have the widest range of sample rates
599 if (deviceInfo.m_dataFormats.empty() ||
600 std::find(deviceInfo.m_dataFormats.cbegin(), deviceInfo.m_dataFormats.cend(),
601 AE_FMT_S16NE) != deviceInfo.m_dataFormats.cend())
602 {
603 wfxex.Format.wBitsPerSample = 16;
604 wfxex.Samples.wValidBitsPerSample = 16;
605 }
606 else
607 {
608 const AEDataFormat fmt = deviceInfo.m_dataFormats.front();
609 wfxex.Format.wBitsPerSample = CAEUtil::DataFormatToBits(fmt);
610 wfxex.Samples.wValidBitsPerSample =
611 (fmt == AE_FMT_S24NE4MSB ? 24 : wfxex.Format.wBitsPerSample);
612 }
613
614 wfxex.Format.nChannels = 2;
615 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
616 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
617
618 for (int j = 0; j < WASAPISampleRateCount; j++)
619 {
620 wfxex.Format.nSamplesPerSec = WASAPISampleRates[j];
621 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
622 hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
623 if (SUCCEEDED(hr))
624 deviceInfo.m_sampleRates.push_back(WASAPISampleRates[j]);
625 else if (wfxex.Format.nSamplesPerSec == 192000 && add192)
626 {
627 deviceInfo.m_sampleRates.push_back(WASAPISampleRates[j]);
628 CLog::LogF(LOGINFO, "sample rate 192khz on device \"{}\" seems to be not supported.",
629 details.strDescription);
630 }
631 else if (wfxex.Format.nSamplesPerSec == 48000 && add48)
632 {
633 deviceInfo.m_sampleRates.push_back(WASAPISampleRates[j]);
634 CLog::LogF(LOGINFO, "sample rate 48khz on device \"{}\" seems to be not supported.",
635 details.strDescription);
636 }
637 }
638 pClient = nullptr;
639 }
640 else
641 {
642 CLog::LogF(LOGDEBUG, "Failed to activate device for passthrough capability testing.");
643 }
644
645 deviceInfo.m_deviceName = details.strDeviceId;
646 deviceInfo.m_displayName = details.strWinDevType.append(details.strDescription);
647 deviceInfo.m_displayNameExtra = std::string("WASAPI: ").append(details.strDescription);
648 deviceInfo.m_deviceType = details.eDeviceType;
649 deviceInfo.m_channels = deviceChannels;
650
651 /* Store the device info */
652 deviceInfo.m_wantsIECPassthrough = true;
653 deviceInfo.m_onlyPassthrough = onlyPT;
654
655 if (!deviceInfo.m_streamTypes.empty())
656 deviceInfo.m_dataFormats.push_back(AE_FMT_RAW);
657
658 deviceInfoList.push_back(deviceInfo);
659
660 if (details.bDefault)
661 {
662 deviceInfo.m_deviceName = std::string("default");
663 deviceInfo.m_displayName = std::string("default");
664 deviceInfo.m_displayNameExtra = std::string("");
665 deviceInfo.m_wantsIECPassthrough = true;
666 deviceInfo.m_onlyPassthrough = onlyPT;
667 deviceInfoList.push_back(deviceInfo);
668 }
669
670 SafeRelease(&pDevice);
671 }
672 return;
673
674 failed:
675
676 if (FAILED(hr))
677 CLog::LogF(LOGERROR, "Failed to enumerate WASAPI endpoint devices ({}).",
678 CWIN32Util::FormatHRESULT(hr));
679 }
680
681 //Private utility functions////////////////////////////////////////////////////
682
683 void CAESinkWASAPI::BuildWaveFormatExtensibleIEC61397(AEAudioFormat &format, WAVEFORMATEXTENSIBLE_IEC61937 &wfxex)
684 {
685 /* Fill the common structure */
686 CAESinkFactoryWin::BuildWaveFormatExtensible(format, wfxex.FormatExt);
687
688 /* Code below kept for future use - preferred for later Windows versions */
689 /* but can cause problems on older Windows versions and drivers */
690 /*
691 wfxex.FormatExt.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE_IEC61937)-sizeof(WAVEFORMATEX);
692 wfxex.dwEncodedChannelCount = format.m_channelLayout.Count();
693 wfxex.dwEncodedSamplesPerSec = bool(format.m_dataFormat == AE_FMT_TRUEHD ||
694 format.m_dataFormat == AE_FMT_DTSHD ||
695 format.m_dataFormat == AE_FMT_EAC3) ? 96000L : 48000L;
696 wfxex.dwAverageBytesPerSec = 0; //Ignored */
697 }
698
699 bool CAESinkWASAPI::InitializeExclusive(AEAudioFormat &format)
700 {
701 WAVEFORMATEXTENSIBLE_IEC61937 wfxex_iec61937;
702 WAVEFORMATEXTENSIBLE &wfxex = wfxex_iec61937.FormatExt;
703
704 if (format.m_dataFormat <= AE_FMT_FLOAT)
705 CAESinkFactoryWin::BuildWaveFormatExtensible(format, wfxex);
706 else if (format.m_dataFormat == AE_FMT_RAW)
707 BuildWaveFormatExtensibleIEC61397(format, wfxex_iec61937);
708 else
709 {
710 // planar formats are currently not supported by this sink
711 format.m_dataFormat = AE_FMT_FLOAT;
712 CAESinkFactoryWin::BuildWaveFormatExtensible(format, wfxex);
713 }
714
715 // Prevents NULL speaker mask. To do: debug exact cause.
716 // When this happens requested AE format is AE_FMT_FLOAT + channel layout
717 // RAW, RAW, RAW... (6 channels). Only happens at end of playback PT
718 // stream, force to defaults does not affect functionality or user
719 // experience. Only avoids crash.
720 if (!wfxex.dwChannelMask && format.m_dataFormat <= AE_FMT_FLOAT)
721 {
722 CLog::LogF(LOGWARNING, "NULL Channel Mask detected. Default values are enforced.");
723 format.m_sampleRate = 0; // force defaults in following code
724 }
725
726 /* Test for incomplete format and provide defaults */
727 if (format.m_sampleRate == 0 ||
728 format.m_channelLayout == CAEChannelInfo(nullptr) ||
729 format.m_dataFormat <= AE_FMT_INVALID ||
730 format.m_dataFormat >= AE_FMT_MAX ||
731 format.m_channelLayout.Count() == 0)
732 {
733 wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
734 wfxex.Format.nChannels = 2;
735 wfxex.Format.nSamplesPerSec = 44100L;
736 wfxex.Format.wBitsPerSample = 16;
737 wfxex.Format.nBlockAlign = 4;
738 wfxex.Samples.wValidBitsPerSample = 16;
739 wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
740 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nBlockAlign * wfxex.Format.nSamplesPerSec;
741 wfxex.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
742 wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
743 }
744
745 HRESULT hr = m_pAudioClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
746
747 int closestMatch = 0;
748 unsigned int requestedChannels = 0;
749 unsigned int noOfCh = 0;
750 uint64_t desired_map = 0;
751 bool matchNoChannelsOnly = false;
752
753 if (SUCCEEDED(hr))
754 {
755 CLog::LogF(LOGINFO, "Format is Supported - will attempt to Initialize");
756 goto initialize;
757 }
758 else if (hr != AUDCLNT_E_UNSUPPORTED_FORMAT) //It failed for a reason unrelated to an unsupported format.
759 {
760 CLog::LogF(LOGERROR, "IsFormatSupported failed ({})", CWIN32Util::FormatHRESULT(hr));
761 return false;
762 }
763 else if (format.m_dataFormat == AE_FMT_RAW) //No sense in trying other formats for passthrough.
764 return false;
765
766 CLog::LogF(LOGWARNING,
767 "format {} not supported by the device - trying to find a compatible format",
768 CAEUtil::DataFormatToStr(format.m_dataFormat));
769
770 requestedChannels = wfxex.Format.nChannels;
771 desired_map = CAESinkFactoryWin::SpeakerMaskFromAEChannels(format.m_channelLayout);
772
773 /* The requested format is not supported by the device. Find something that works */
774 CLog::LogF(LOGWARNING, "Input channels are [{}] - Trying to find a matching output layout",
775 std::string(format.m_channelLayout));
776
777 for (int layout = -1; layout <= (int)ARRAYSIZE(layoutsList); layout++)
778 {
779 // if requested layout is not supported, try standard layouts which contain
780 // at least the same channels as the input source
781 // as the last resort try stereo
782 if (layout == ARRAYSIZE(layoutsList))
783 {
784 if (matchNoChannelsOnly)
785 {
786 wfxex.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
787 wfxex.Format.nChannels = 2;
788 }
789 else
790 {
791 matchNoChannelsOnly = true;
792 layout = -1;
793 CLog::Log(LOGWARNING, "AESinkWASAPI: Match only number of audio channels as fallback");
794 continue;
795 }
796 }
797 else if (layout >= 0)
798 {
799 wfxex.dwChannelMask = CAESinkFactoryWin::ChLayoutToChMask(layoutsList[layout], &noOfCh);
800 wfxex.Format.nChannels = noOfCh;
801 int res = desired_map & wfxex.dwChannelMask;
802 if (matchNoChannelsOnly)
803 {
804 if (noOfCh < requestedChannels)
805 continue; // number of channels doesn't match requested channels
806 }
807 else
808 {
809 if (res != desired_map)
810 continue; // output channel layout doesn't match input channels
811 }
812 }
813 CAEChannelInfo foundChannels;
814 CAESinkFactoryWin::AEChannelsFromSpeakerMask(foundChannels, wfxex.dwChannelMask);
815 CLog::Log(LOGDEBUG, "AESinkWASAPI: Trying matching channel layout [{}]",
816 std::string(foundChannels));
817
818 for (int j = 0; j < sizeof(testFormats)/sizeof(sampleFormat); j++)
819 {
820 closestMatch = -1;
821
822 wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
823 wfxex.SubFormat = testFormats[j].subFormat;
824 wfxex.Format.wBitsPerSample = testFormats[j].bitsPerSample;
825 wfxex.Samples.wValidBitsPerSample = testFormats[j].validBitsPerSample;
826 wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
827
828 for (int i = 0 ; i < WASAPISampleRateCount; i++)
829 {
830 wfxex.Format.nSamplesPerSec = WASAPISampleRates[i];
831 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
832
833 /* Trace format match iteration loop via log */
834 #if 0
835 CLog::Log(LOGDEBUG, "WASAPI: Trying Format: {}, {}, {}, {}", CAEUtil::DataFormatToStr(testFormats[j].subFormatType),
836 wfxex.Format.nSamplesPerSec,
837 wfxex.Format.wBitsPerSample,
838 wfxex.Samples.wValidBitsPerSample);
839 #endif
840
841 hr = m_pAudioClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL);
842
843 if (SUCCEEDED(hr))
844 {
845 /* If the current sample rate matches the source then stop looking and use it */
846 if ((WASAPISampleRates[i] == format.m_sampleRate) && (testFormats[j].subFormatType <= format.m_dataFormat))
847 goto initialize;
848 /* If this rate is closer to the source then the previous one, save it */
849 else if (closestMatch < 0 || abs((int)WASAPISampleRates[i] - (int)format.m_sampleRate) < abs((int)WASAPISampleRates[closestMatch] - (int)format.m_sampleRate))
850 closestMatch = i;
851 }
852 else if (hr != AUDCLNT_E_UNSUPPORTED_FORMAT)
853 CLog::LogF(LOGERROR, "IsFormatSupported failed ({})", CWIN32Util::FormatHRESULT(hr));
854 }
855
856 if (closestMatch >= 0)
857 {
858 wfxex.Format.nSamplesPerSec = WASAPISampleRates[closestMatch];
859 wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
860 goto initialize;
861 }
862 }
863 CLog::Log(LOGDEBUG, "AESinkWASAPI: Format [{}] not supported by driver",
864 std::string(foundChannels));
865 }
866
867 CLog::LogF(LOGERROR, "Unable to locate a supported output format for the device. "
868 "Check the speaker settings in the control panel.");
869
870 /* We couldn't find anything supported. This should never happen */
871 /* unless the user set the wrong speaker setting in the control panel */
872 return false;
873
874 initialize:
875
876 CAESinkFactoryWin::AEChannelsFromSpeakerMask(m_channelLayout, wfxex.dwChannelMask);
877 format.m_channelLayout = m_channelLayout;
878
879 /* When the stream is raw, the values in the format structure are set to the link */
880 /* parameters, so store the encoded stream values here for the IsCompatible function */
881 m_encodedChannels = wfxex.Format.nChannels;
882 m_encodedSampleRate = (format.m_dataFormat == AE_FMT_RAW) ? format.m_streamInfo.m_sampleRate : format.m_sampleRate;
883 wfxex_iec61937.dwEncodedChannelCount = wfxex.Format.nChannels;
884 wfxex_iec61937.dwEncodedSamplesPerSec = m_encodedSampleRate;
885
886 /* Set up returned sink format for engine */
887 if (format.m_dataFormat != AE_FMT_RAW)
888 {
889 if (wfxex.Format.wBitsPerSample == 32)
890 {
891 if (wfxex.SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)
892 format.m_dataFormat = AE_FMT_FLOAT;
893 else if (wfxex.Samples.wValidBitsPerSample == 32)
894 format.m_dataFormat = AE_FMT_S32NE;
895 else
896 format.m_dataFormat = AE_FMT_S24NE4MSB;
897 }
898 else if (wfxex.Format.wBitsPerSample == 24)
899 format.m_dataFormat = AE_FMT_S24NE3;
900 else
901 format.m_dataFormat = AE_FMT_S16NE;
902 }
903
904 format.m_sampleRate = wfxex.Format.nSamplesPerSec; //PCM: Sample rate. RAW: Link speed
905 format.m_frameSize = (wfxex.Format.wBitsPerSample >> 3) * wfxex.Format.nChannels;
906
907 ComPtr<IAudioClient2> audioClient2;
908 if (SUCCEEDED(m_pAudioClient.As(&audioClient2)))
909 {
910 AudioClientProperties props = {};
911 props.cbSize = sizeof(props);
912 // ForegroundOnlyMedia/BackgroundCapableMedia replaced in Windows 10 by Movie/Media
913 props.eCategory = CSysInfo::IsWindowsVersionAtLeast(CSysInfo::WindowsVersionWin10)
914 ? AudioCategory_Media
915 : AudioCategory_ForegroundOnlyMedia;
916
917 if (FAILED(hr = audioClient2->SetClientProperties(&props)))
918 CLog::LogF(LOGERROR, "unable to set audio category, {}", CWIN32Util::FormatHRESULT(hr));
919 }
920
921 REFERENCE_TIME audioSinkBufferDurationMsec, hnsLatency;
922
923 audioSinkBufferDurationMsec = (REFERENCE_TIME)500000;
924 if (IsUSBDevice())
925 {
926 CLog::LogF(LOGDEBUG, "detected USB device, increasing buffer size");
927 audioSinkBufferDurationMsec = (REFERENCE_TIME)1000000;
928 }
929 audioSinkBufferDurationMsec = (REFERENCE_TIME)((audioSinkBufferDurationMsec / format.m_frameSize) * format.m_frameSize); //even number of frames
930
931 if (format.m_dataFormat == AE_FMT_RAW)
932 format.m_dataFormat = AE_FMT_S16NE;
933
934 hr = m_pAudioClient->Initialize(AUDCLNT_SHAREMODE_EXCLUSIVE, AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
935 audioSinkBufferDurationMsec, audioSinkBufferDurationMsec, &wfxex.Format, NULL);
936
937 if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED)
938 {
939 /* WASAPI requires aligned buffer */
940 /* Get the next aligned frame */
941 hr = m_pAudioClient->GetBufferSize(&m_uiBufferLen);
942 if (FAILED(hr))
943 {
944 CLog::LogF(LOGERROR, "GetBufferSize Failed : {}", CWIN32Util::FormatHRESULT(hr));
945 return false;
946 }
947
948 audioSinkBufferDurationMsec = (REFERENCE_TIME) ((10000.0 * 1000 / wfxex.Format.nSamplesPerSec * m_uiBufferLen) + 0.5);
949
950 /* Release the previous allocations */
951 /* Create a new audio client */
952 hr = m_pDevice->Activate(m_pAudioClient.ReleaseAndGetAddressOf());
953 if (FAILED(hr))
954 {
955 CLog::LogF(LOGERROR, "Device Activation Failed : {}", CWIN32Util::FormatHRESULT(hr));
956 return false;
957 }
958
959 /* Open the stream and associate it with an audio session */
960 hr = m_pAudioClient->Initialize(AUDCLNT_SHAREMODE_EXCLUSIVE, AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
961 audioSinkBufferDurationMsec, audioSinkBufferDurationMsec, &wfxex.Format, NULL);
962 }
963 if (FAILED(hr))
964 {
965 CLog::LogF(LOGERROR, "Failed to initialize WASAPI in exclusive mode - {}.",
966 CWIN32Util::FormatHRESULT(hr));
967 CLog::Log(LOGDEBUG, " Sample Rate : {}", wfxex.Format.nSamplesPerSec);
968 CLog::Log(LOGDEBUG, " Sample Format : {}", CAEUtil::DataFormatToStr(format.m_dataFormat));
969 CLog::Log(LOGDEBUG, " Bits Per Sample : {}", wfxex.Format.wBitsPerSample);
970 CLog::Log(LOGDEBUG, " Valid Bits/Samp : {}", wfxex.Samples.wValidBitsPerSample);
971 CLog::Log(LOGDEBUG, " Channel Count : {}", wfxex.Format.nChannels);
972 CLog::Log(LOGDEBUG, " Block Align : {}", wfxex.Format.nBlockAlign);
973 CLog::Log(LOGDEBUG, " Avg. Bytes Sec : {}", wfxex.Format.nAvgBytesPerSec);
974 CLog::Log(LOGDEBUG, " Samples/Block : {}", wfxex.Samples.wSamplesPerBlock);
975 CLog::Log(LOGDEBUG, " Format cBSize : {}", wfxex.Format.cbSize);
976 CLog::Log(LOGDEBUG, " Channel Layout : {}", ((std::string)format.m_channelLayout));
977 CLog::Log(LOGDEBUG, " Enc. Channels : {}", wfxex_iec61937.dwEncodedChannelCount);
978 CLog::Log(LOGDEBUG, " Enc. Samples/Sec: {}", wfxex_iec61937.dwEncodedSamplesPerSec);
979 CLog::Log(LOGDEBUG, " Channel Mask : {}", wfxex.dwChannelMask);
980 CLog::Log(LOGDEBUG, " Periodicty : {}", audioSinkBufferDurationMsec);
981 return false;
982 }
983
984 /* Latency of WASAPI buffers in event-driven mode is equal to the returned value */
985 /* of GetStreamLatency converted from 100ns intervals to seconds then multiplied */
986 /* by two as there are two equally-sized buffers and playback starts when the */
987 /* second buffer is filled. Multiplying the returned 100ns intervals by 0.0000002 */
988 /* is handles both the unit conversion and twin buffers. */
989 hr = m_pAudioClient->GetStreamLatency(&hnsLatency);
990 if (FAILED(hr))
991 {
992 CLog::LogF(LOGERROR, "GetStreamLatency Failed : {}", CWIN32Util::FormatHRESULT(hr));
993 return false;
994 }
995
996 m_sinkLatency = hnsLatency * 0.0000002;
997
998 CLog::LogF(LOGINFO, "WASAPI Exclusive Mode Sink Initialized using: {}, {}, {}",
999 CAEUtil::DataFormatToStr(format.m_dataFormat), wfxex.Format.nSamplesPerSec,
1000 wfxex.Format.nChannels);
1001 return true;
1002 }
1003
1004 void CAESinkWASAPI::Drain()
1005 {
1006 if(!m_pAudioClient)
1007 return;
1008
1009 AEDelayStatus status;
1010 GetDelay(status);
1011
1012 KODI::TIME::Sleep(std::chrono::milliseconds(static_cast<int>(status.GetDelay() * 500)));
1013
1014 if (m_running)
1015 {
1016 try
1017 {
1018 m_pAudioClient->Stop(); //stop the audio output
1019 m_pAudioClient->Reset(); //flush buffer and reset audio clock stream position
1020 m_sinkFrames = 0;
1021 }
1022 catch (...)
1023 {
1024 CLog::LogF(LOGDEBUG, "Invalidated AudioClient - Releasing");
1025 }
1026 }
1027 m_running = false;
1028 }
1029
1030 bool CAESinkWASAPI::IsUSBDevice()
1031 {
1032 return m_pDevice && m_pDevice->IsUSBDevice();
1033 }
XBMC Media Center