xbmc/cores/AudioEngine/Sinks/AESinkXAudio.cpp

   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 "AESinkXAudio.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "cores/AudioEngine/AESinkFactory.h"
  13 #include "cores/AudioEngine/Sinks/windows/AESinkFactoryWin.h"
  14 #include "cores/AudioEngine/Utils/AEDeviceInfo.h"
  15 #include "cores/AudioEngine/Utils/AEUtil.h"
  16 #include "utils/SystemInfo.h"
  17 #include "utils/log.h"
  18
  19 #include "platform/win32/CharsetConverter.h"
  20
  21 #include <algorithm>
  22 #include <stdint.h>
  23
  24 #include <ksmedia.h>
  25
  26 using namespace Microsoft::WRL;
  27
  28 namespace
  29 {
  30 constexpr int XAUDIO_BUFFERS_IN_QUEUE = 2;
  31
  32 HRESULT KXAudio2Create(IXAudio2** ppXAudio2,
  33                        UINT32 Flags X2DEFAULT(0),
  34                        XAUDIO2_PROCESSOR XAudio2Processor X2DEFAULT(XAUDIO2_DEFAULT_PROCESSOR))
  35 {
  36   typedef HRESULT(__stdcall * XAudio2CreateInfoFunc)(_Outptr_ IXAudio2**, UINT32,
  37                                                      XAUDIO2_PROCESSOR);
  38   static HMODULE dll = NULL;
  39   static XAudio2CreateInfoFunc XAudio2CreateFn = nullptr;
  40
  41   if (dll == NULL)
  42   {
  43     dll = LoadLibraryEx(L"xaudio2_9redist.dll", NULL, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
  44
  45     if (dll == NULL)
  46     {
  47       dll = LoadLibraryEx(L"xaudio2_9.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
  48
  49       if (dll == NULL)
  50       {
  51         // Windows 8 compatibility
  52         dll = LoadLibraryEx(L"xaudio2_8.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
  53
  54         if (dll == NULL)
  55           return HRESULT_FROM_WIN32(GetLastError());
  56       }
  57     }
  58
  59     XAudio2CreateFn = (XAudio2CreateInfoFunc)(void*)GetProcAddress(dll, "XAudio2Create");
  60     if (!XAudio2CreateFn)
  61     {
  62       return HRESULT_FROM_WIN32(GetLastError());
  63     }
  64   }
  65
  66   if (XAudio2CreateFn)
  67     return (*XAudio2CreateFn)(ppXAudio2, Flags, XAudio2Processor);
  68   else
  69     return E_FAIL;
  70 }
  71
  72 } // namespace
  73
  74 extern const char* WASAPIErrToStr(HRESULT err);
  75
  76 template <class TVoice>
  77 inline void SafeDestroyVoice(TVoice **ppVoice)
  78 {
  79   if (*ppVoice)
  80   {
  81     (*ppVoice)->DestroyVoice();
  82     *ppVoice = nullptr;
  83   }
  84 }
  85
  86 CAESinkXAudio::CAESinkXAudio()
  87 {
  88   HRESULT hr = KXAudio2Create(m_xAudio2.ReleaseAndGetAddressOf(), 0);
  89   if (FAILED(hr))
  90   {
  91     CLog::LogF(LOGERROR, "XAudio initialization failed, error {:X}.", hr);
  92   }
  93 #ifdef _DEBUG
  94   else
  95   {
  96     XAUDIO2_DEBUG_CONFIGURATION config = {};
  97     config.BreakMask = XAUDIO2_LOG_ERRORS | XAUDIO2_LOG_WARNINGS | XAUDIO2_LOG_API_CALLS | XAUDIO2_LOG_STREAMING;
  98     config.TraceMask = XAUDIO2_LOG_ERRORS | XAUDIO2_LOG_WARNINGS | XAUDIO2_LOG_API_CALLS | XAUDIO2_LOG_STREAMING;
  99     config.LogTiming = true;
 100     config.LogFunctionName = true;
 101     m_xAudio2->SetDebugConfiguration(&config, 0);
 102   }
 103 #endif // _DEBUG
 104
 105   // Get performance counter frequency for latency calculations
 106   QueryPerformanceFrequency(&m_timerFreq);
 107 }
 108
 109 CAESinkXAudio::~CAESinkXAudio()
 110 {
 111   if (m_xAudio2)
 112     m_xAudio2.Reset();
 113 }
 114
 115 void CAESinkXAudio::Register()
 116 {
 117   AE::AESinkRegEntry reg;
 118   reg.sinkName = "XAUDIO";
 119   reg.createFunc = CAESinkXAudio::Create;
 120   reg.enumerateFunc = CAESinkXAudio::EnumerateDevicesEx;
 121   AE::CAESinkFactory::RegisterSink(reg);
 122 }
 123
 124 std::unique_ptr<IAESink> CAESinkXAudio::Create(std::string& device, AEAudioFormat& desiredFormat)
 125 {
 126   auto sink = std::make_unique<CAESinkXAudio>();
 127
 128   if (!sink->m_xAudio2)
 129   {
 130     CLog::LogF(LOGERROR, "XAudio2 not loaded.");
 131     return {};
 132   }
 133
 134   if (sink->Initialize(desiredFormat, device))
 135     return sink;
 136
 137   return {};
 138 }
 139
 140 bool CAESinkXAudio::Initialize(AEAudioFormat &format, std::string &device)
 141 {
 142   if (m_initialized)
 143     return false;
 144
 145   /* Save requested format */
 146   AEDataFormat reqFormat = format.m_dataFormat;
 147
 148   if (!InitializeInternal(device, format))
 149   {
 150     CLog::LogF(LOGINFO, "could not Initialize voices with format {}",
 151                CAEUtil::DataFormatToStr(reqFormat));
 152     CLog::LogF(LOGERROR, "XAudio initialization failed");
 153     return false;
 154   }
 155
 156   m_initialized = true;
 157   m_isDirty = false;
 158
 159   return true;
 160 }
 161
 162 void CAESinkXAudio::Deinitialize()
 163 {
 164   if (!m_initialized && !m_isDirty)
 165     return;
 166
 167   if (m_running)
 168   {
 169     try
 170     {
 171       m_sourceVoice->Stop();
 172       m_sourceVoice->FlushSourceBuffers();
 173
 174       // Stop and FlushSourceBuffers are async, wait for queued buffers to be released by XAudio2.
 175       // callbacks don't seem to be called otherwise, with memory leakage.
 176       XAUDIO2_VOICE_STATE state{};
 177       do
 178       {
 179         if (WAIT_OBJECT_0 != WaitForSingleObject(m_voiceCallback.mBufferEnd.get(), 500))
 180         {
 181           CLog::LogF(LOGERROR, "timeout waiting for buffer flush - possible buffer memory leak");
 182           break;
 183         }
 184         m_sourceVoice->GetState(&state, 0);
 185       } while (state.BuffersQueued > 0);
 186
 187       m_sinkFrames = 0;
 188       m_framesInBuffers = 0;
 189     }
 190     catch (...)
 191     {
 192       CLog::LogF(LOGERROR, "invalidated source voice - Releasing");
 193     }
 194   }
 195   m_running = false;
 196
 197   SafeDestroyVoice(&m_sourceVoice);
 198   SafeDestroyVoice(&m_masterVoice);
 199
 200   m_initialized = false;
 201 }
 202
 203 void CAESinkXAudio::GetDelay(AEDelayStatus& status)
 204 {
 205   if (!m_initialized)
 206   {
 207     status.SetDelay(0.0);
 208     return;
 209   }
 210
 211   XAUDIO2_VOICE_STATE state;
 212   m_sourceVoice->GetState(&state, 0);
 213
 214   status.SetDelay(static_cast<double>(m_sinkFrames - state.SamplesPlayed) / m_format.m_sampleRate);
 215   return;
 216 }
 217
 218 double CAESinkXAudio::GetCacheTotal()
 219 {
 220   if (!m_initialized)
 221     return 0.0;
 222
 223   return static_cast<double>(XAUDIO_BUFFERS_IN_QUEUE * m_format.m_frames) / m_format.m_sampleRate;
 224 }
 225
 226 double CAESinkXAudio::GetLatency()
 227 {
 228   if (!m_initialized || !m_xAudio2)
 229     return 0.0;
 230
 231   XAUDIO2_PERFORMANCE_DATA perfData;
 232   m_xAudio2->GetPerformanceData(&perfData);
 233
 234   return static_cast<double>(perfData.CurrentLatencyInSamples) / m_format.m_sampleRate;
 235 }
 236
 237 unsigned int CAESinkXAudio::AddPackets(uint8_t **data, unsigned int frames, unsigned int offset)
 238 {
 239   if (!m_initialized)
 240     return 0;
 241
 242   HRESULT hr = S_OK;
 243
 244   LARGE_INTEGER timerStart;
 245   LARGE_INTEGER timerStop;
 246
 247   XAUDIO2_BUFFER xbuffer = BuildXAudio2Buffer(data, frames, offset);
 248
 249   if (!m_running) //first time called, pre-fill buffer then start voice
 250   {
 251     m_sourceVoice->Stop();
 252     hr = m_sourceVoice->SubmitSourceBuffer(&xbuffer);
 253     if (FAILED(hr))
 254     {
 255       CLog::LogF(LOGERROR, "voice submit buffer failed due to {}", WASAPIErrToStr(hr));
 256       delete xbuffer.pContext;
 257       return 0;
 258     }
 259     hr = m_sourceVoice->Start(0, XAUDIO2_COMMIT_NOW);
 260     if (FAILED(hr))
 261     {
 262       CLog::LogF(LOGERROR, "voice start failed due to {}", WASAPIErrToStr(hr));
 263       m_isDirty = true; //flag new device or re-init needed
 264       delete xbuffer.pContext;
 265       return INT_MAX;
 266     }
 267     m_sinkFrames += frames;
 268     m_framesInBuffers += frames;
 269     m_running = true; //signal that we're processing frames
 270     return frames;
 271   }
 272
 273   /* Get clock time for latency checks */
 274   QueryPerformanceCounter(&timerStart);
 275
 276   /* Wait for Audio Driver to tell us it's got a buffer available */
 277   while (m_format.m_frames * XAUDIO_BUFFERS_IN_QUEUE <= m_framesInBuffers.load())
 278   {
 279     DWORD eventAudioCallback;
 280     eventAudioCallback = WaitForSingleObjectEx(m_voiceCallback.mBufferEnd.get(), 1100, TRUE);
 281     if (eventAudioCallback != WAIT_OBJECT_0)
 282     {
 283       CLog::LogF(LOGERROR, "voice buffer timed out");
 284       delete xbuffer.pContext;
 285       return INT_MAX;
 286     }
 287   }
 288
 289   if (!m_running)
 290     return 0;
 291
 292   QueryPerformanceCounter(&timerStop);
 293   const LONGLONG timerDiff = timerStop.QuadPart - timerStart.QuadPart;
 294   const double timerElapsed = static_cast<double>(timerDiff) * 1000.0 / m_timerFreq.QuadPart;
 295   m_avgTimeWaiting += (timerElapsed - m_avgTimeWaiting) * 0.5;
 296
 297   if (m_avgTimeWaiting < 3.0)
 298   {
 299     CLog::LogF(LOGDEBUG, "Possible AQ Loss: Avg. Time Waiting for Audio Driver callback : {}msec",
 300                (int)m_avgTimeWaiting);
 301   }
 302
 303   hr = m_sourceVoice->SubmitSourceBuffer(&xbuffer);
 304   if (FAILED(hr))
 305   {
 306     CLog::LogF(LOGERROR, "submiting buffer failed due to {}", WASAPIErrToStr(hr));
 307     delete xbuffer.pContext;
 308     return INT_MAX;
 309   }
 310
 311   m_sinkFrames += frames;
 312   m_framesInBuffers += frames;
 313
 314   return frames;
 315 }
 316
 317 void CAESinkXAudio::EnumerateDevicesEx(AEDeviceInfoList &deviceInfoList, bool force)
 318 {
 319   HRESULT hr = S_OK;
 320   CAEDeviceInfo deviceInfo;
 321   CAEChannelInfo deviceChannels;
 322   WAVEFORMATEXTENSIBLE wfxex = {};
 323   UINT32 eflags = 0; // XAUDIO2_DEBUG_ENGINE;
 324   IXAudio2MasteringVoice* mMasterVoice = nullptr;
 325   IXAudio2SourceVoice* mSourceVoice = nullptr;
 326   Microsoft::WRL::ComPtr<IXAudio2> xaudio2;
 327
 328   // ForegroundOnlyMedia/BackgroundCapableMedia replaced in Windows 10 by Movie/Media
 329   const AUDIO_STREAM_CATEGORY streamCategory{
 330       CSysInfo::IsWindowsVersionAtLeast(CSysInfo::WindowsVersionWin10)
 331           ? AudioCategory_Media
 332           : AudioCategory_ForegroundOnlyMedia};
 333
 334   hr = KXAudio2Create(xaudio2.ReleaseAndGetAddressOf(), eflags);
 335   if (FAILED(hr))
 336   {
 337     CLog::LogF(LOGERROR, "failed to activate XAudio for capability testing ({})",
 338                WASAPIErrToStr(hr));
 339     return;
 340   }
 341
 342   for (RendererDetail& details : CAESinkFactoryWin::GetRendererDetailsWinRT())
 343   {
 344     deviceInfo.m_channels.Reset();
 345     deviceInfo.m_dataFormats.clear();
 346     deviceInfo.m_sampleRates.clear();
 347     deviceChannels.Reset();
 348
 349     for (unsigned int c = 0; c < WASAPI_SPEAKER_COUNT; c++)
 350     {
 351       if (details.uiChannelMask & WASAPIChannelOrder[c])
 352         deviceChannels += AEChannelNames[c];
 353     }
 354
 355     const std::wstring deviceId = KODI::PLATFORM::WINDOWS::ToW(details.strDeviceId);
 356
 357     /* Test format for PCM format iteration */
 358     wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 359     wfxex.Format.nSamplesPerSec = 48000;
 360     wfxex.Format.nChannels = 2;
 361     wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO;
 362     wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 363     wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 364
 365     hr = xaudio2->CreateMasteringVoice(&mMasterVoice, wfxex.Format.nChannels,
 366                                        wfxex.Format.nSamplesPerSec, 0, deviceId.c_str(), nullptr,
 367                                        streamCategory);
 368
 369     if (FAILED(hr))
 370     {
 371       CLog::LogF(LOGERROR, "failed to create mastering voice (:X)", hr);
 372       return;
 373     }
 374
 375     for (int p = AE_FMT_FLOAT; p > AE_FMT_INVALID; p--)
 376     {
 377       if (p < AE_FMT_FLOAT)
 378         wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 379       wfxex.Format.wBitsPerSample = CAEUtil::DataFormatToBits((AEDataFormat)p);
 380       wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
 381       wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
 382       if (p == AE_FMT_S24NE4MSB)
 383       {
 384         wfxex.Samples.wValidBitsPerSample = 24;
 385       }
 386       else if (p <= AE_FMT_S24NE4 && p >= AE_FMT_S24BE4)
 387       {
 388         // not supported
 389         continue;
 390       }
 391       else
 392       {
 393         wfxex.Samples.wValidBitsPerSample = wfxex.Format.wBitsPerSample;
 394       }
 395
 396       SafeDestroyVoice(&mSourceVoice);
 397       hr = xaudio2->CreateSourceVoice(&mSourceVoice, &wfxex.Format);
 398
 399       if (SUCCEEDED(hr))
 400         deviceInfo.m_dataFormats.push_back((AEDataFormat)p);
 401     }
 402
 403     /* Test format for sample rate iteration */
 404     wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 405     wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO;
 406     wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 407     wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 408     wfxex.Format.wBitsPerSample = 16;
 409     wfxex.Samples.wValidBitsPerSample = 16;
 410     wfxex.Format.nChannels = 2;
 411     wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
 412     wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
 413
 414     for (int j = 0; j < WASAPISampleRateCount; j++)
 415     {
 416       if (WASAPISampleRates[j] < XAUDIO2_MIN_SAMPLE_RATE ||
 417           WASAPISampleRates[j] > XAUDIO2_MAX_SAMPLE_RATE)
 418         continue;
 419
 420       SafeDestroyVoice(&mSourceVoice);
 421       SafeDestroyVoice(&mMasterVoice);
 422
 423       wfxex.Format.nSamplesPerSec = WASAPISampleRates[j];
 424       wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
 425
 426       if (SUCCEEDED(xaudio2->CreateMasteringVoice(&mMasterVoice, wfxex.Format.nChannels,
 427                                                   wfxex.Format.nSamplesPerSec, 0, deviceId.c_str(),
 428                                                   nullptr, streamCategory)))
 429       {
 430         hr = xaudio2->CreateSourceVoice(&mSourceVoice, &wfxex.Format);
 431
 432         if (SUCCEEDED(hr))
 433           deviceInfo.m_sampleRates.push_back(WASAPISampleRates[j]);
 434       }
 435     }
 436
 437     SafeDestroyVoice(&mSourceVoice);
 438     SafeDestroyVoice(&mMasterVoice);
 439
 440     deviceInfo.m_deviceName = details.strDeviceId;
 441     deviceInfo.m_displayName = details.strWinDevType.append(details.strDescription);
 442     deviceInfo.m_displayNameExtra = std::string("XAudio: ").append(details.strDescription);
 443     deviceInfo.m_deviceType = details.eDeviceType;
 444     deviceInfo.m_channels = deviceChannels;
 445
 446     /* Store the device info */
 447     deviceInfo.m_wantsIECPassthrough = true;
 448     deviceInfo.m_onlyPCM = true;
 449
 450     if (!deviceInfo.m_streamTypes.empty())
 451       deviceInfo.m_dataFormats.push_back(AE_FMT_RAW);
 452
 453     deviceInfoList.push_back(deviceInfo);
 454
 455     if (details.bDefault)
 456     {
 457       deviceInfo.m_deviceName = std::string("default");
 458       deviceInfo.m_displayName = std::string("default");
 459       deviceInfo.m_displayNameExtra = std::string("");
 460       deviceInfo.m_wantsIECPassthrough = true;
 461       deviceInfo.m_onlyPCM = true;
 462       deviceInfoList.push_back(deviceInfo);
 463     }
 464   }
 465 }
 466
 467 bool CAESinkXAudio::InitializeInternal(std::string deviceId, AEAudioFormat &format)
 468 {
 469   const std::wstring device = KODI::PLATFORM::WINDOWS::ToW(deviceId);
 470   WAVEFORMATEXTENSIBLE wfxex = {};
 471
 472   if ( format.m_dataFormat <= AE_FMT_FLOAT
 473     || format.m_dataFormat == AE_FMT_RAW)
 474     CAESinkFactoryWin::BuildWaveFormatExtensible(format, wfxex);
 475   else
 476   {
 477     // planar formats are currently not supported by this sink
 478     format.m_dataFormat = AE_FMT_FLOAT;
 479     CAESinkFactoryWin::BuildWaveFormatExtensible(format, wfxex);
 480   }
 481
 482   /* Test for incomplete format and provide defaults */
 483   if (format.m_sampleRate == 0 ||
 484       format.m_channelLayout == CAEChannelInfo(nullptr) ||
 485       format.m_dataFormat <= AE_FMT_INVALID ||
 486       format.m_dataFormat >= AE_FMT_MAX ||
 487       format.m_channelLayout.Count() == 0)
 488   {
 489     wfxex.Format.wFormatTag           = WAVE_FORMAT_EXTENSIBLE;
 490     wfxex.Format.nChannels            = 2;
 491     wfxex.Format.nSamplesPerSec       = 44100L;
 492     wfxex.Format.wBitsPerSample       = 16;
 493     wfxex.Format.nBlockAlign          = 4;
 494     wfxex.Samples.wValidBitsPerSample = 16;
 495     wfxex.Format.cbSize               = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 496     wfxex.Format.nAvgBytesPerSec      = wfxex.Format.nBlockAlign * wfxex.Format.nSamplesPerSec;
 497     wfxex.dwChannelMask               = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
 498     wfxex.SubFormat                   = KSDATAFORMAT_SUBTYPE_PCM;
 499   }
 500
 501   const bool bdefault = deviceId.find("default") != std::string::npos;
 502
 503   HRESULT hr;
 504   IXAudio2MasteringVoice* pMasterVoice = nullptr;
 505   // ForegroundOnlyMedia/BackgroundCapableMedia replaced in Windows 10 by Movie/Media
 506   const AUDIO_STREAM_CATEGORY streamCategory{
 507       CSysInfo::IsWindowsVersionAtLeast(CSysInfo::WindowsVersionWin10)
 508           ? AudioCategory_Media
 509           : AudioCategory_ForegroundOnlyMedia};
 510
 511   if (!bdefault)
 512   {
 513     hr = m_xAudio2->CreateMasteringVoice(&pMasterVoice, wfxex.Format.nChannels,
 514                                          wfxex.Format.nSamplesPerSec, 0, device.c_str(), nullptr,
 515                                          streamCategory);
 516   }
 517
 518   if (!pMasterVoice)
 519   {
 520     if (!bdefault)
 521     {
 522       CLog::LogF(LOGINFO,
 523                  "could not locate the device named \"{}\" in the list of Xaudio endpoint devices. "
 524                  "Trying the default device...",
 525                  KODI::PLATFORM::WINDOWS::FromW(device));
 526     }
 527
 528     // smartphone issue: providing device ID (even default ID) causes E_NOINTERFACE result
 529     // workaround: device = nullptr will initialize default audio endpoint
 530     hr = m_xAudio2->CreateMasteringVoice(&pMasterVoice, wfxex.Format.nChannels,
 531                                          wfxex.Format.nSamplesPerSec, 0, nullptr, nullptr,
 532                                          streamCategory);
 533     if (FAILED(hr) || !pMasterVoice)
 534     {
 535       CLog::LogF(LOGINFO, "Could not retrieve the default XAudio audio endpoint ({}).",
 536                  WASAPIErrToStr(hr));
 537       return false;
 538     }
 539   }
 540
 541   m_masterVoice = pMasterVoice;
 542
 543   int closestMatch = 0;
 544   unsigned int requestedChannels = 0;
 545   unsigned int noOfCh = 0;
 546
 547   hr = m_xAudio2->CreateSourceVoice(&m_sourceVoice, &wfxex.Format, 0, XAUDIO2_DEFAULT_FREQ_RATIO, &m_voiceCallback);
 548   if (SUCCEEDED(hr))
 549   {
 550     CLog::LogF(LOGINFO, "Format is Supported - will attempt to Initialize");
 551     goto initialize;
 552   }
 553
 554   if (format.m_dataFormat == AE_FMT_RAW) //No sense in trying other formats for passthrough.
 555     return false;
 556
 557   if (CServiceBroker::GetLogging().CanLogComponent(LOGAUDIO))
 558     CLog::LogFC(LOGDEBUG, LOGAUDIO,
 559                 "CreateSourceVoice failed ({}) - trying to find a compatible format",
 560                 WASAPIErrToStr(hr));
 561
 562   requestedChannels = wfxex.Format.nChannels;
 563
 564   /* The requested format is not supported by the device.  Find something that works */
 565   for (int layout = -1; layout <= (int)ARRAYSIZE(layoutsList); layout++)
 566   {
 567     // if requested layout is not supported, try standard layouts with at least
 568     // the number of channels as requested
 569     // as the last resort try stereo
 570     if (layout == ARRAYSIZE(layoutsList))
 571     {
 572       wfxex.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
 573       wfxex.Format.nChannels = 2;
 574     }
 575     else if (layout >= 0)
 576     {
 577       wfxex.dwChannelMask = CAESinkFactoryWin::ChLayoutToChMask(layoutsList[layout], &noOfCh);
 578       wfxex.Format.nChannels = noOfCh;
 579       if (noOfCh < requestedChannels)
 580         continue;
 581     }
 582
 583     for (int j = 0; j < sizeof(testFormats)/sizeof(sampleFormat); j++)
 584     {
 585       closestMatch = -1;
 586
 587       wfxex.Format.wFormatTag           = WAVE_FORMAT_EXTENSIBLE;
 588       wfxex.SubFormat                   = testFormats[j].subFormat;
 589       wfxex.Format.wBitsPerSample       = testFormats[j].bitsPerSample;
 590       wfxex.Samples.wValidBitsPerSample = testFormats[j].validBitsPerSample;
 591       wfxex.Format.nBlockAlign          = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3);
 592
 593       for (int i = 0 ; i < WASAPISampleRateCount; i++)
 594       {
 595         if (WASAPISampleRates[j] < XAUDIO2_MIN_SAMPLE_RATE ||
 596             WASAPISampleRates[j] > XAUDIO2_MAX_SAMPLE_RATE)
 597           continue;
 598
 599         SafeDestroyVoice(&m_sourceVoice);
 600         SafeDestroyVoice(&m_masterVoice);
 601
 602         wfxex.Format.nSamplesPerSec    = WASAPISampleRates[i];
 603         wfxex.Format.nAvgBytesPerSec   = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
 604
 605         hr = m_xAudio2->CreateMasteringVoice(&m_masterVoice, wfxex.Format.nChannels,
 606                                              wfxex.Format.nSamplesPerSec, 0, device.c_str(),
 607                                              nullptr, streamCategory);
 608         if (SUCCEEDED(hr))
 609         {
 610           hr = m_xAudio2->CreateSourceVoice(&m_sourceVoice, &wfxex.Format, 0, XAUDIO2_DEFAULT_FREQ_RATIO, &m_voiceCallback);
 611           if (SUCCEEDED(hr))
 612           {
 613             /* If the current sample rate matches the source then stop looking and use it */
 614             if ((WASAPISampleRates[i] == format.m_sampleRate) && (testFormats[j].subFormatType <= format.m_dataFormat))
 615               goto initialize;
 616             /* If this rate is closer to the source then the previous one, save it */
 617             else if (closestMatch < 0 || abs((int)WASAPISampleRates[i] - (int)format.m_sampleRate) < abs((int)WASAPISampleRates[closestMatch] - (int)format.m_sampleRate))
 618               closestMatch = i;
 619           }
 620         }
 621
 622         if (FAILED(hr))
 623           CLog::LogF(LOGERROR, "creating voices failed ({})", WASAPIErrToStr(hr));
 624       }
 625
 626       if (closestMatch >= 0)
 627       {
 628         // Closest match may be different from the last successful sample rate tested
 629         SafeDestroyVoice(&m_sourceVoice);
 630         SafeDestroyVoice(&m_masterVoice);
 631
 632         wfxex.Format.nSamplesPerSec    = WASAPISampleRates[closestMatch];
 633         wfxex.Format.nAvgBytesPerSec   = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign;
 634
 635         if (SUCCEEDED(m_xAudio2->CreateMasteringVoice(&m_masterVoice, wfxex.Format.nChannels,
 636                                                       wfxex.Format.nSamplesPerSec, 0,
 637                                                       device.c_str(), nullptr, streamCategory)) &&
 638             SUCCEEDED(m_xAudio2->CreateSourceVoice(&m_sourceVoice, &wfxex.Format, 0,
 639                                                    XAUDIO2_DEFAULT_FREQ_RATIO, &m_voiceCallback)))
 640           goto initialize;
 641       }
 642     }
 643   }
 644
 645   CLog::LogF(LOGERROR, "unable to locate a supported output format for the device. Check the "
 646                        "speaker settings in the control panel.");
 647
 648   /* We couldn't find anything supported. This should never happen      */
 649   /* unless the user set the wrong speaker setting in the control panel */
 650   return false;
 651
 652 initialize:
 653
 654   CAEChannelInfo channelLayout;
 655   CAESinkFactoryWin::AEChannelsFromSpeakerMask(channelLayout, wfxex.dwChannelMask);
 656   format.m_channelLayout = channelLayout;
 657
 658   /* Set up returned sink format for engine */
 659   if (format.m_dataFormat != AE_FMT_RAW)
 660   {
 661     if (wfxex.Format.wBitsPerSample == 32)
 662     {
 663       if (wfxex.SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)
 664         format.m_dataFormat = AE_FMT_FLOAT;
 665       else if (wfxex.Samples.wValidBitsPerSample == 32)
 666         format.m_dataFormat = AE_FMT_S32NE;
 667       else
 668         format.m_dataFormat = AE_FMT_S24NE4MSB;
 669     }
 670     else if (wfxex.Format.wBitsPerSample == 24)
 671       format.m_dataFormat = AE_FMT_S24NE3;
 672     else
 673       format.m_dataFormat = AE_FMT_S16NE;
 674   }
 675
 676   format.m_sampleRate    = wfxex.Format.nSamplesPerSec; //PCM: Sample rate.  RAW: Link speed
 677   format.m_frameSize     = (wfxex.Format.wBitsPerSample >> 3) * wfxex.Format.nChannels;
 678
 679   if (format.m_dataFormat == AE_FMT_RAW)
 680     format.m_dataFormat = AE_FMT_S16NE;
 681
 682   hr = m_sourceVoice->Start(0, XAUDIO2_COMMIT_NOW);
 683   if (FAILED(hr))
 684   {
 685     CLog::LogF(LOGERROR, "Voice start failed : {}", WASAPIErrToStr(hr));
 686     CLog::Log(LOGDEBUG, "  Sample Rate     : {}", wfxex.Format.nSamplesPerSec);
 687     CLog::Log(LOGDEBUG, "  Sample Format   : {}", CAEUtil::DataFormatToStr(format.m_dataFormat));
 688     CLog::Log(LOGDEBUG, "  Bits Per Sample : {}", wfxex.Format.wBitsPerSample);
 689     CLog::Log(LOGDEBUG, "  Valid Bits/Samp : {}", wfxex.Samples.wValidBitsPerSample);
 690     CLog::Log(LOGDEBUG, "  Channel Count   : {}", wfxex.Format.nChannels);
 691     CLog::Log(LOGDEBUG, "  Block Align     : {}", wfxex.Format.nBlockAlign);
 692     CLog::Log(LOGDEBUG, "  Avg. Bytes Sec  : {}", wfxex.Format.nAvgBytesPerSec);
 693     CLog::Log(LOGDEBUG, "  Samples/Block   : {}", wfxex.Samples.wSamplesPerBlock);
 694     CLog::Log(LOGDEBUG, "  Format cBSize   : {}", wfxex.Format.cbSize);
 695     CLog::Log(LOGDEBUG, "  Channel Layout  : {}", ((std::string)format.m_channelLayout));
 696     CLog::Log(LOGDEBUG, "  Channel Mask    : {}", wfxex.dwChannelMask);
 697     return false;
 698   }
 699
 700   XAUDIO2_PERFORMANCE_DATA perfData;
 701   m_xAudio2->GetPerformanceData(&perfData);
 702   if (!perfData.TotalSourceVoiceCount)
 703   {
 704     CLog::LogF(LOGERROR, "GetPerformanceData Failed : {}", WASAPIErrToStr(hr));
 705     return false;
 706   }
 707
 708   format.m_frames = static_cast<int>(format.m_sampleRate * 0.02); // 20 ms chunks
 709
 710   m_format = format;
 711
 712   CLog::LogF(LOGINFO, "XAudio Sink Initialized using: {}, {}, {}",
 713              CAEUtil::DataFormatToStr(format.m_dataFormat), wfxex.Format.nSamplesPerSec,
 714              wfxex.Format.nChannels);
 715
 716   m_sourceVoice->Stop();
 717
 718   CLog::LogF(LOGDEBUG, "Initializing XAudio with the following parameters:");
 719   CLog::Log(LOGDEBUG, "  Audio Device    : {}", KODI::PLATFORM::WINDOWS::FromW(device));
 720   CLog::Log(LOGDEBUG, "  Sample Rate     : {}", wfxex.Format.nSamplesPerSec);
 721   CLog::Log(LOGDEBUG, "  Sample Format   : {}", CAEUtil::DataFormatToStr(format.m_dataFormat));
 722   CLog::Log(LOGDEBUG, "  Bits Per Sample : {}", wfxex.Format.wBitsPerSample);
 723   CLog::Log(LOGDEBUG, "  Valid Bits/Samp : {}", wfxex.Samples.wValidBitsPerSample);
 724   CLog::Log(LOGDEBUG, "  Channel Count   : {}", wfxex.Format.nChannels);
 725   CLog::Log(LOGDEBUG, "  Block Align     : {}", wfxex.Format.nBlockAlign);
 726   CLog::Log(LOGDEBUG, "  Avg. Bytes Sec  : {}", wfxex.Format.nAvgBytesPerSec);
 727   CLog::Log(LOGDEBUG, "  Samples/Block   : {}", wfxex.Samples.wSamplesPerBlock);
 728   CLog::Log(LOGDEBUG, "  Format cBSize   : {}", wfxex.Format.cbSize);
 729   CLog::Log(LOGDEBUG, "  Channel Layout  : {}", ((std::string)format.m_channelLayout));
 730   CLog::Log(LOGDEBUG, "  Channel Mask    : {}", wfxex.dwChannelMask);
 731   CLog::Log(LOGDEBUG, "  Frames          : {}", format.m_frames);
 732   CLog::Log(LOGDEBUG, "  Frame Size      : {}", format.m_frameSize);
 733
 734   return true;
 735 }
 736
 737 void CAESinkXAudio::Drain()
 738 {
 739   if(!m_sourceVoice)
 740     return;
 741
 742   if (m_running)
 743   {
 744     try
 745     {
 746       // Contrary to MS doc, the voice must play a buffer with end of stream flag for the voice
 747       // SamplesPlayed counter to be reset.
 748       // Per MS doc, Discontinuity() may not take effect until after the entire buffer queue is
 749       // consumed, which wouldn't invoke the callback or reset the voice stats.
 750       // Solution: submit a 1 sample buffer with end of stream flag and wait for StreamEnd callback
 751       // The StreamEnd event is manual reset so that it cannot be missed even if raised before this
 752       // code starts waiting for it
 753
 754       AddEndOfStreamPacket();
 755
 756       constexpr uint32_t waitSafety = 100; // extra ms wait in case of scheduler issue
 757       DWORD waitRc =
 758           WaitForSingleObject(m_voiceCallback.m_StreamEndEvent,
 759                               m_framesInBuffers * 1000 / m_format.m_sampleRate + waitSafety);
 760
 761       if (waitRc != WAIT_OBJECT_0)
 762       {
 763         if (waitRc == WAIT_FAILED)
 764         {
 765           //! @todo use FormatMessage for a human readable error message
 766           CLog::LogF(LOGERROR,
 767                      "error WAIT_FAILED while waiting for queued buffers to drain. GetLastError:{}",
 768                      GetLastError());
 769         }
 770         else
 771         {
 772           CLog::LogF(LOGERROR, "error {} while waiting for queued buffers to drain.", waitRc);
 773         }
 774       }
 775
 776       m_sourceVoice->Stop();
 777       ResetEvent(m_voiceCallback.m_StreamEndEvent);
 778
 779       m_sinkFrames = 0;
 780       m_framesInBuffers = 0;
 781     }
 782     catch (...)
 783     {
 784       CLog::LogF(LOGERROR, "invalidated source voice - Releasing");
 785     }
 786   }
 787   m_running = false;
 788 }
 789
 790 bool CAESinkXAudio::AddEndOfStreamPacket()
 791 {
 792   constexpr unsigned int frames{1};
 793
 794   XAUDIO2_BUFFER xbuffer = BuildXAudio2Buffer(nullptr, frames, 0);
 795   xbuffer.Flags = XAUDIO2_END_OF_STREAM;
 796
 797   HRESULT hr = m_sourceVoice->SubmitSourceBuffer(&xbuffer);
 798
 799   if (hr != S_OK)
 800   {
 801     CLog::LogF(LOGERROR, "SubmitSourceBuffer failed due to {:X}", hr);
 802     delete xbuffer.pContext;
 803     return false;
 804   }
 805
 806   m_sinkFrames += frames;
 807   m_framesInBuffers += frames;
 808   return true;
 809 }
 810
 811 XAUDIO2_BUFFER CAESinkXAudio::BuildXAudio2Buffer(uint8_t** data,
 812                                                  unsigned int frames,
 813                                                  unsigned int offset)
 814 {
 815   const unsigned int dataLength{frames * m_format.m_frameSize};
 816
 817   struct buffer_ctx* ctx = new buffer_ctx;
 818   ctx->data = new uint8_t[dataLength];
 819   ctx->frames = frames;
 820   ctx->sink = this;
 821
 822   if (data)
 823     memcpy(ctx->data, data[0] + offset * m_format.m_frameSize, dataLength);
 824   else
 825     CAEUtil::GenerateSilence(m_format.m_dataFormat, m_format.m_frameSize, ctx->data, frames);
 826
 827   XAUDIO2_BUFFER xbuffer{};
 828   xbuffer.AudioBytes = dataLength;
 829   xbuffer.pAudioData = ctx->data;
 830   xbuffer.pContext = ctx;
 831
 832   return xbuffer;
 833 }