1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #pragma warning(disable: 4995) // name was marked as #pragma deprecated 12 13 #if (_MSC_VER >= 1310) && (_MSC_VER < 1400) 14 // Reports the major and minor versions of the compiler. 15 // For example, 1310 for Microsoft Visual C++ .NET 2003. 1310 represents version 13 and a 1.0 point release. 16 // The Visual C++ 2005 compiler version is 1400. 17 // Type cl /? at the command line to see the major and minor versions of your compiler along with the build number. 18 #pragma message(">> INFO: Windows Core Audio is not supported in VS 2003") 19 #endif 20 21 #include "webrtc/modules/audio_device/audio_device_config.h" 22 23 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) 24 #pragma message(">> INFO: WEBRTC_WINDOWS_CORE_AUDIO_BUILD is defined") 25 #else 26 #pragma message(">> INFO: WEBRTC_WINDOWS_CORE_AUDIO_BUILD is *not* defined") 27 #endif 28 29 #ifdef WEBRTC_WINDOWS_CORE_AUDIO_BUILD 30 31 #include "webrtc/modules/audio_device/win/audio_device_core_win.h" 32 33 #include <assert.h> 34 #include <string.h> 35 36 #include <windows.h> 37 #include <comdef.h> 38 #include <dmo.h> 39 #include <Functiondiscoverykeys_devpkey.h> 40 #include <mmsystem.h> 41 #include <strsafe.h> 42 #include <uuids.h> 43 44 #include "webrtc/modules/audio_device/audio_device_utility.h" 45 #include "webrtc/system_wrappers/interface/sleep.h" 46 #include "webrtc/system_wrappers/interface/trace.h" 47 48 // Macro that calls a COM method returning HRESULT value. 49 #define EXIT_ON_ERROR(hres) do { if (FAILED(hres)) goto Exit; } while(0) 50 51 // Macro that continues to a COM error. 52 #define CONTINUE_ON_ERROR(hres) do { if (FAILED(hres)) goto Next; } while(0) 53 54 // Macro that releases a COM object if not NULL. 55 #define SAFE_RELEASE(p) do { if ((p)) { (p)->Release(); (p) = NULL; } } while(0) 56 57 #define ROUND(x) ((x) >=0 ? (int)((x) + 0.5) : (int)((x) - 0.5)) 58 59 // REFERENCE_TIME time units per millisecond 60 #define REFTIMES_PER_MILLISEC 10000 61 62 typedef struct tagTHREADNAME_INFO 63 { 64 DWORD dwType; // must be 0x1000 65 LPCSTR szName; // pointer to name (in user addr space) 66 DWORD dwThreadID; // thread ID (-1=caller thread) 67 DWORD dwFlags; // reserved for future use, must be zero 68 } THREADNAME_INFO; 69 70 namespace webrtc { 71 namespace { 72 73 enum { COM_THREADING_MODEL = COINIT_MULTITHREADED }; 74 75 enum 76 { 77 kAecCaptureStreamIndex = 0, 78 kAecRenderStreamIndex = 1 79 }; 80 81 // An implementation of IMediaBuffer, as required for 82 // IMediaObject::ProcessOutput(). After consuming data provided by 83 // ProcessOutput(), call SetLength() to update the buffer availability. 84 // 85 // Example implementation: 86 // http://msdn.microsoft.com/en-us/library/dd376684(v=vs.85).aspx 87 class MediaBufferImpl : public IMediaBuffer 88 { 89 public: 90 explicit MediaBufferImpl(DWORD maxLength) 91 : _data(new BYTE[maxLength]), 92 _length(0), 93 _maxLength(maxLength), 94 _refCount(0) 95 {} 96 97 // IMediaBuffer methods. 98 STDMETHOD(GetBufferAndLength(BYTE** ppBuffer, DWORD* pcbLength)) 99 { 100 if (!ppBuffer || !pcbLength) 101 { 102 return E_POINTER; 103 } 104 105 *ppBuffer = _data; 106 *pcbLength = _length; 107 108 return S_OK; 109 } 110 111 STDMETHOD(GetMaxLength(DWORD* pcbMaxLength)) 112 { 113 if (!pcbMaxLength) 114 { 115 return E_POINTER; 116 } 117 118 *pcbMaxLength = _maxLength; 119 return S_OK; 120 } 121 122 STDMETHOD(SetLength(DWORD cbLength)) 123 { 124 if (cbLength > _maxLength) 125 { 126 return E_INVALIDARG; 127 } 128 129 _length = cbLength; 130 return S_OK; 131 } 132 133 // IUnknown methods. 134 STDMETHOD_(ULONG, AddRef()) 135 { 136 return InterlockedIncrement(&_refCount); 137 } 138 139 STDMETHOD(QueryInterface(REFIID riid, void** ppv)) 140 { 141 if (!ppv) 142 { 143 return E_POINTER; 144 } 145 else if (riid != IID_IMediaBuffer && riid != IID_IUnknown) 146 { 147 return E_NOINTERFACE; 148 } 149 150 *ppv = static_cast<IMediaBuffer*>(this); 151 AddRef(); 152 return S_OK; 153 } 154 155 STDMETHOD_(ULONG, Release()) 156 { 157 LONG refCount = InterlockedDecrement(&_refCount); 158 if (refCount == 0) 159 { 160 delete this; 161 } 162 163 return refCount; 164 } 165 166 private: 167 ~MediaBufferImpl() 168 { 169 delete [] _data; 170 } 171 172 BYTE* _data; 173 DWORD _length; 174 const DWORD _maxLength; 175 LONG _refCount; 176 }; 177 } // namespace 178 179 // ============================================================================ 180 // Static Methods 181 // ============================================================================ 182 183 // ---------------------------------------------------------------------------- 184 // CoreAudioIsSupported 185 // ---------------------------------------------------------------------------- 186 187 bool AudioDeviceWindowsCore::CoreAudioIsSupported() 188 { 189 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, -1, "%s", __FUNCTION__); 190 191 bool MMDeviceIsAvailable(false); 192 bool coreAudioIsSupported(false); 193 194 HRESULT hr(S_OK); 195 TCHAR buf[MAXERRORLENGTH]; 196 TCHAR errorText[MAXERRORLENGTH]; 197 198 // 1) Check if Windows version is Vista SP1 or later. 199 // 200 // CoreAudio is only available on Vista SP1 and later. 201 // 202 OSVERSIONINFOEX osvi; 203 DWORDLONG dwlConditionMask = 0; 204 int op = VER_LESS_EQUAL; 205 206 // Initialize the OSVERSIONINFOEX structure. 207 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); 208 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 209 osvi.dwMajorVersion = 6; 210 osvi.dwMinorVersion = 0; 211 osvi.wServicePackMajor = 0; 212 osvi.wServicePackMinor = 0; 213 osvi.wProductType = VER_NT_WORKSTATION; 214 215 // Initialize the condition mask. 216 VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, op); 217 VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, op); 218 VER_SET_CONDITION(dwlConditionMask, VER_SERVICEPACKMAJOR, op); 219 VER_SET_CONDITION(dwlConditionMask, VER_SERVICEPACKMINOR, op); 220 VER_SET_CONDITION(dwlConditionMask, VER_PRODUCT_TYPE, VER_EQUAL); 221 222 DWORD dwTypeMask = VER_MAJORVERSION | VER_MINORVERSION | 223 VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR | 224 VER_PRODUCT_TYPE; 225 226 // Perform the test. 227 BOOL isVistaRTMorXP = VerifyVersionInfo(&osvi, dwTypeMask, 228 dwlConditionMask); 229 if (isVistaRTMorXP != 0) 230 { 231 WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, -1, 232 "*** Windows Core Audio is only supported on Vista SP1 or later " 233 "=> will revert to the Wave API ***"); 234 return false; 235 } 236 237 // 2) Initializes the COM library for use by the calling thread. 238 239 // The COM init wrapper sets the thread's concurrency model to MTA, 240 // and creates a new apartment for the thread if one is required. The 241 // wrapper also ensures that each call to CoInitializeEx is balanced 242 // by a corresponding call to CoUninitialize. 243 // 244 ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA); 245 if (!comInit.succeeded()) { 246 // Things will work even if an STA thread is calling this method but we 247 // want to ensure that MTA is used and therefore return false here. 248 return false; 249 } 250 251 // 3) Check if the MMDevice API is available. 252 // 253 // The Windows Multimedia Device (MMDevice) API enables audio clients to 254 // discover audio endpoint devices, determine their capabilities, and create 255 // driver instances for those devices. 256 // Header file Mmdeviceapi.h defines the interfaces in the MMDevice API. 257 // The MMDevice API consists of several interfaces. The first of these is the 258 // IMMDeviceEnumerator interface. To access the interfaces in the MMDevice API, 259 // a client obtains a reference to the IMMDeviceEnumerator interface of a 260 // device-enumerator object by calling the CoCreateInstance function. 261 // 262 // Through the IMMDeviceEnumerator interface, the client can obtain references 263 // to the other interfaces in the MMDevice API. The MMDevice API implements 264 // the following interfaces: 265 // 266 // IMMDevice Represents an audio device. 267 // IMMDeviceCollection Represents a collection of audio devices. 268 // IMMDeviceEnumerator Provides methods for enumerating audio devices. 269 // IMMEndpoint Represents an audio endpoint device. 270 // 271 IMMDeviceEnumerator* pIMMD(NULL); 272 const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator); 273 const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator); 274 275 hr = CoCreateInstance( 276 CLSID_MMDeviceEnumerator, // GUID value of MMDeviceEnumerator coclass 277 NULL, 278 CLSCTX_ALL, 279 IID_IMMDeviceEnumerator, // GUID value of the IMMDeviceEnumerator interface 280 (void**)&pIMMD ); 281 282 if (FAILED(hr)) 283 { 284 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, 285 "AudioDeviceWindowsCore::CoreAudioIsSupported() Failed to create the required COM object", hr); 286 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, -1, 287 "AudioDeviceWindowsCore::CoreAudioIsSupported() CoCreateInstance(MMDeviceEnumerator) failed (hr=0x%x)", hr); 288 289 const DWORD dwFlags = FORMAT_MESSAGE_FROM_SYSTEM | 290 FORMAT_MESSAGE_IGNORE_INSERTS; 291 const DWORD dwLangID = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US); 292 293 // Gets the system's human readable message string for this HRESULT. 294 // All error message in English by default. 295 DWORD messageLength = ::FormatMessageW(dwFlags, 296 0, 297 hr, 298 dwLangID, 299 errorText, 300 MAXERRORLENGTH, 301 NULL); 302 303 assert(messageLength <= MAXERRORLENGTH); 304 305 // Trims tailing white space (FormatMessage() leaves a trailing cr-lf.). 306 for (; messageLength && ::isspace(errorText[messageLength - 1]); 307 --messageLength) 308 { 309 errorText[messageLength - 1] = '\0'; 310 } 311 312 StringCchPrintf(buf, MAXERRORLENGTH, TEXT("Error details: ")); 313 StringCchCat(buf, MAXERRORLENGTH, errorText); 314 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, -1, "%S", buf); 315 } 316 else 317 { 318 MMDeviceIsAvailable = true; 319 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, -1, 320 "AudioDeviceWindowsCore::CoreAudioIsSupported() CoCreateInstance(MMDeviceEnumerator) succeeded", hr); 321 SAFE_RELEASE(pIMMD); 322 } 323 324 // 4) Verify that we can create and initialize our Core Audio class. 325 // 326 // Also, perform a limited "API test" to ensure that Core Audio is supported for all devices. 327 // 328 if (MMDeviceIsAvailable) 329 { 330 coreAudioIsSupported = false; 331 332 AudioDeviceWindowsCore* p = new AudioDeviceWindowsCore(-1); 333 if (p == NULL) 334 { 335 return false; 336 } 337 338 int ok(0); 339 int temp_ok(0); 340 bool available(false); 341 342 ok |= p->Init(); 343 344 int16_t numDevsRec = p->RecordingDevices(); 345 for (uint16_t i = 0; i < numDevsRec; i++) 346 { 347 ok |= p->SetRecordingDevice(i); 348 temp_ok = p->RecordingIsAvailable(available); 349 ok |= temp_ok; 350 ok |= (available == false); 351 if (available) 352 { 353 ok |= p->InitMicrophone(); 354 } 355 if (ok) 356 { 357 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, -1, 358 "AudioDeviceWindowsCore::CoreAudioIsSupported() Failed to use Core Audio Recording for device id=%i", i); 359 } 360 } 361 362 int16_t numDevsPlay = p->PlayoutDevices(); 363 for (uint16_t i = 0; i < numDevsPlay; i++) 364 { 365 ok |= p->SetPlayoutDevice(i); 366 temp_ok = p->PlayoutIsAvailable(available); 367 ok |= temp_ok; 368 ok |= (available == false); 369 if (available) 370 { 371 ok |= p->InitSpeaker(); 372 } 373 if (ok) 374 { 375 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, -1 , 376 "AudioDeviceWindowsCore::CoreAudioIsSupported() Failed to use Core Audio Playout for device id=%i", i); 377 } 378 } 379 380 ok |= p->Terminate(); 381 382 if (ok == 0) 383 { 384 coreAudioIsSupported = true; 385 } 386 387 delete p; 388 } 389 390 if (coreAudioIsSupported) 391 { 392 WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, -1, "*** Windows Core Audio is supported ***"); 393 } 394 else 395 { 396 WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, -1, "*** Windows Core Audio is NOT supported => will revert to the Wave API ***"); 397 } 398 399 return (coreAudioIsSupported); 400 } 401 402 // ============================================================================ 403 // Construction & Destruction 404 // ============================================================================ 405 406 // ---------------------------------------------------------------------------- 407 // AudioDeviceWindowsCore() - ctor 408 // ---------------------------------------------------------------------------- 409 410 AudioDeviceWindowsCore::AudioDeviceWindowsCore(const int32_t id) : 411 _comInit(ScopedCOMInitializer::kMTA), 412 _critSect(*CriticalSectionWrapper::CreateCriticalSection()), 413 _volumeMutex(*CriticalSectionWrapper::CreateCriticalSection()), 414 _id(id), 415 _ptrAudioBuffer(NULL), 416 _ptrEnumerator(NULL), 417 _ptrRenderCollection(NULL), 418 _ptrCaptureCollection(NULL), 419 _ptrDeviceOut(NULL), 420 _ptrDeviceIn(NULL), 421 _ptrClientOut(NULL), 422 _ptrClientIn(NULL), 423 _ptrRenderClient(NULL), 424 _ptrCaptureClient(NULL), 425 _ptrCaptureVolume(NULL), 426 _ptrRenderSimpleVolume(NULL), 427 _dmo(NULL), 428 _mediaBuffer(NULL), 429 _builtInAecEnabled(false), 430 _playAudioFrameSize(0), 431 _playSampleRate(0), 432 _playBlockSize(0), 433 _playChannels(2), 434 _sndCardPlayDelay(0), 435 _sndCardRecDelay(0), 436 _writtenSamples(0), 437 _readSamples(0), 438 _playAcc(0), 439 _recAudioFrameSize(0), 440 _recSampleRate(0), 441 _recBlockSize(0), 442 _recChannels(2), 443 _avrtLibrary(NULL), 444 _winSupportAvrt(false), 445 _hRenderSamplesReadyEvent(NULL), 446 _hPlayThread(NULL), 447 _hCaptureSamplesReadyEvent(NULL), 448 _hRecThread(NULL), 449 _hShutdownRenderEvent(NULL), 450 _hShutdownCaptureEvent(NULL), 451 _hRenderStartedEvent(NULL), 452 _hCaptureStartedEvent(NULL), 453 _hGetCaptureVolumeThread(NULL), 454 _hSetCaptureVolumeThread(NULL), 455 _hSetCaptureVolumeEvent(NULL), 456 _hMmTask(NULL), 457 _initialized(false), 458 _recording(false), 459 _playing(false), 460 _recIsInitialized(false), 461 _playIsInitialized(false), 462 _speakerIsInitialized(false), 463 _microphoneIsInitialized(false), 464 _AGC(false), 465 _playWarning(0), 466 _playError(0), 467 _recWarning(0), 468 _recError(0), 469 _playBufType(AudioDeviceModule::kAdaptiveBufferSize), 470 _playBufDelay(80), 471 _playBufDelayFixed(80), 472 _usingInputDeviceIndex(false), 473 _usingOutputDeviceIndex(false), 474 _inputDevice(AudioDeviceModule::kDefaultCommunicationDevice), 475 _outputDevice(AudioDeviceModule::kDefaultCommunicationDevice), 476 _inputDeviceIndex(0), 477 _outputDeviceIndex(0), 478 _newMicLevel(0) 479 { 480 WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__); 481 assert(_comInit.succeeded()); 482 483 // Try to load the Avrt DLL 484 if (!_avrtLibrary) 485 { 486 // Get handle to the Avrt DLL module. 487 _avrtLibrary = LoadLibrary(TEXT("Avrt.dll")); 488 if (_avrtLibrary) 489 { 490 // Handle is valid (should only happen if OS larger than vista & win7). 491 // Try to get the function addresses. 492 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::AudioDeviceWindowsCore() The Avrt DLL module is now loaded"); 493 494 _PAvRevertMmThreadCharacteristics = (PAvRevertMmThreadCharacteristics)GetProcAddress(_avrtLibrary, "AvRevertMmThreadCharacteristics"); 495 _PAvSetMmThreadCharacteristicsA = (PAvSetMmThreadCharacteristicsA)GetProcAddress(_avrtLibrary, "AvSetMmThreadCharacteristicsA"); 496 _PAvSetMmThreadPriority = (PAvSetMmThreadPriority)GetProcAddress(_avrtLibrary, "AvSetMmThreadPriority"); 497 498 if ( _PAvRevertMmThreadCharacteristics && 499 _PAvSetMmThreadCharacteristicsA && 500 _PAvSetMmThreadPriority) 501 { 502 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::AudioDeviceWindowsCore() AvRevertMmThreadCharacteristics() is OK"); 503 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::AudioDeviceWindowsCore() AvSetMmThreadCharacteristicsA() is OK"); 504 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::AudioDeviceWindowsCore() AvSetMmThreadPriority() is OK"); 505 _winSupportAvrt = true; 506 } 507 } 508 } 509 510 // Create our samples ready events - we want auto reset events that start in the not-signaled state. 511 // The state of an auto-reset event object remains signaled until a single waiting thread is released, 512 // at which time the system automatically sets the state to nonsignaled. If no threads are waiting, 513 // the event object's state remains signaled. 514 // (Except for _hShutdownCaptureEvent, which is used to shutdown multiple threads). 515 _hRenderSamplesReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 516 _hCaptureSamplesReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 517 _hShutdownRenderEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 518 _hShutdownCaptureEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 519 _hRenderStartedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 520 _hCaptureStartedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 521 _hSetCaptureVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL); 522 523 _perfCounterFreq.QuadPart = 1; 524 _perfCounterFactor = 0.0; 525 _avgCPULoad = 0.0; 526 527 // list of number of channels to use on recording side 528 _recChannelsPrioList[0] = 2; // stereo is prio 1 529 _recChannelsPrioList[1] = 1; // mono is prio 2 530 531 // list of number of channels to use on playout side 532 _playChannelsPrioList[0] = 2; // stereo is prio 1 533 _playChannelsPrioList[1] = 1; // mono is prio 2 534 535 HRESULT hr; 536 537 // We know that this API will work since it has already been verified in 538 // CoreAudioIsSupported, hence no need to check for errors here as well. 539 540 // Retrive the IMMDeviceEnumerator API (should load the MMDevAPI.dll) 541 // TODO(henrika): we should probably move this allocation to Init() instead 542 // and deallocate in Terminate() to make the implementation more symmetric. 543 CoCreateInstance( 544 __uuidof(MMDeviceEnumerator), 545 NULL, 546 CLSCTX_ALL, 547 __uuidof(IMMDeviceEnumerator), 548 reinterpret_cast<void**>(&_ptrEnumerator)); 549 assert(NULL != _ptrEnumerator); 550 551 // DMO initialization for built-in WASAPI AEC. 552 { 553 IMediaObject* ptrDMO = NULL; 554 hr = CoCreateInstance(CLSID_CWMAudioAEC, 555 NULL, 556 CLSCTX_INPROC_SERVER, 557 IID_IMediaObject, 558 reinterpret_cast<void**>(&ptrDMO)); 559 if (FAILED(hr) || ptrDMO == NULL) 560 { 561 // Since we check that _dmo is non-NULL in EnableBuiltInAEC(), the 562 // feature is prevented from being enabled. 563 _builtInAecEnabled = false; 564 _TraceCOMError(hr); 565 } 566 _dmo = ptrDMO; 567 SAFE_RELEASE(ptrDMO); 568 } 569 } 570 571 // ---------------------------------------------------------------------------- 572 // AudioDeviceWindowsCore() - dtor 573 // ---------------------------------------------------------------------------- 574 575 AudioDeviceWindowsCore::~AudioDeviceWindowsCore() 576 { 577 WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destroyed", __FUNCTION__); 578 579 Terminate(); 580 581 // The IMMDeviceEnumerator is created during construction. Must release 582 // it here and not in Terminate() since we don't recreate it in Init(). 583 SAFE_RELEASE(_ptrEnumerator); 584 585 _ptrAudioBuffer = NULL; 586 587 if (NULL != _hRenderSamplesReadyEvent) 588 { 589 CloseHandle(_hRenderSamplesReadyEvent); 590 _hRenderSamplesReadyEvent = NULL; 591 } 592 593 if (NULL != _hCaptureSamplesReadyEvent) 594 { 595 CloseHandle(_hCaptureSamplesReadyEvent); 596 _hCaptureSamplesReadyEvent = NULL; 597 } 598 599 if (NULL != _hRenderStartedEvent) 600 { 601 CloseHandle(_hRenderStartedEvent); 602 _hRenderStartedEvent = NULL; 603 } 604 605 if (NULL != _hCaptureStartedEvent) 606 { 607 CloseHandle(_hCaptureStartedEvent); 608 _hCaptureStartedEvent = NULL; 609 } 610 611 if (NULL != _hShutdownRenderEvent) 612 { 613 CloseHandle(_hShutdownRenderEvent); 614 _hShutdownRenderEvent = NULL; 615 } 616 617 if (NULL != _hShutdownCaptureEvent) 618 { 619 CloseHandle(_hShutdownCaptureEvent); 620 _hShutdownCaptureEvent = NULL; 621 } 622 623 if (NULL != _hSetCaptureVolumeEvent) 624 { 625 CloseHandle(_hSetCaptureVolumeEvent); 626 _hSetCaptureVolumeEvent = NULL; 627 } 628 629 if (_avrtLibrary) 630 { 631 BOOL freeOK = FreeLibrary(_avrtLibrary); 632 if (!freeOK) 633 { 634 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 635 "AudioDeviceWindowsCore::~AudioDeviceWindowsCore() failed to free the loaded Avrt DLL module correctly"); 636 } 637 else 638 { 639 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 640 "AudioDeviceWindowsCore::~AudioDeviceWindowsCore() the Avrt DLL module is now unloaded"); 641 } 642 } 643 644 delete &_critSect; 645 delete &_volumeMutex; 646 } 647 648 // ============================================================================ 649 // API 650 // ============================================================================ 651 652 // ---------------------------------------------------------------------------- 653 // AttachAudioBuffer 654 // ---------------------------------------------------------------------------- 655 656 void AudioDeviceWindowsCore::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) 657 { 658 659 _ptrAudioBuffer = audioBuffer; 660 661 // Inform the AudioBuffer about default settings for this implementation. 662 // Set all values to zero here since the actual settings will be done by 663 // InitPlayout and InitRecording later. 664 _ptrAudioBuffer->SetRecordingSampleRate(0); 665 _ptrAudioBuffer->SetPlayoutSampleRate(0); 666 _ptrAudioBuffer->SetRecordingChannels(0); 667 _ptrAudioBuffer->SetPlayoutChannels(0); 668 } 669 670 // ---------------------------------------------------------------------------- 671 // ActiveAudioLayer 672 // ---------------------------------------------------------------------------- 673 674 int32_t AudioDeviceWindowsCore::ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const 675 { 676 audioLayer = AudioDeviceModule::kWindowsCoreAudio; 677 return 0; 678 } 679 680 // ---------------------------------------------------------------------------- 681 // Init 682 // ---------------------------------------------------------------------------- 683 684 int32_t AudioDeviceWindowsCore::Init() 685 { 686 687 CriticalSectionScoped lock(&_critSect); 688 689 if (_initialized) 690 { 691 return 0; 692 } 693 694 _playWarning = 0; 695 _playError = 0; 696 _recWarning = 0; 697 _recError = 0; 698 699 // Enumerate all audio rendering and capturing endpoint devices. 700 // Note that, some of these will not be able to select by the user. 701 // The complete collection is for internal use only. 702 // 703 _EnumerateEndpointDevicesAll(eRender); 704 _EnumerateEndpointDevicesAll(eCapture); 705 706 _initialized = true; 707 708 return 0; 709 } 710 711 // ---------------------------------------------------------------------------- 712 // Terminate 713 // ---------------------------------------------------------------------------- 714 715 int32_t AudioDeviceWindowsCore::Terminate() 716 { 717 718 CriticalSectionScoped lock(&_critSect); 719 720 if (!_initialized) { 721 return 0; 722 } 723 724 _initialized = false; 725 _speakerIsInitialized = false; 726 _microphoneIsInitialized = false; 727 _playing = false; 728 _recording = false; 729 730 SAFE_RELEASE(_ptrRenderCollection); 731 SAFE_RELEASE(_ptrCaptureCollection); 732 SAFE_RELEASE(_ptrDeviceOut); 733 SAFE_RELEASE(_ptrDeviceIn); 734 SAFE_RELEASE(_ptrClientOut); 735 SAFE_RELEASE(_ptrClientIn); 736 SAFE_RELEASE(_ptrRenderClient); 737 SAFE_RELEASE(_ptrCaptureClient); 738 SAFE_RELEASE(_ptrCaptureVolume); 739 SAFE_RELEASE(_ptrRenderSimpleVolume); 740 741 return 0; 742 } 743 744 // ---------------------------------------------------------------------------- 745 // Initialized 746 // ---------------------------------------------------------------------------- 747 748 bool AudioDeviceWindowsCore::Initialized() const 749 { 750 return (_initialized); 751 } 752 753 // ---------------------------------------------------------------------------- 754 // InitSpeaker 755 // ---------------------------------------------------------------------------- 756 757 int32_t AudioDeviceWindowsCore::InitSpeaker() 758 { 759 760 CriticalSectionScoped lock(&_critSect); 761 762 if (_playing) 763 { 764 return -1; 765 } 766 767 if (_ptrDeviceOut == NULL) 768 { 769 return -1; 770 } 771 772 if (_usingOutputDeviceIndex) 773 { 774 int16_t nDevices = PlayoutDevices(); 775 if (_outputDeviceIndex > (nDevices - 1)) 776 { 777 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "current device selection is invalid => unable to initialize"); 778 return -1; 779 } 780 } 781 782 int32_t ret(0); 783 784 SAFE_RELEASE(_ptrDeviceOut); 785 if (_usingOutputDeviceIndex) 786 { 787 // Refresh the selected rendering endpoint device using current index 788 ret = _GetListDevice(eRender, _outputDeviceIndex, &_ptrDeviceOut); 789 } 790 else 791 { 792 ERole role; 793 (_outputDevice == AudioDeviceModule::kDefaultDevice) ? role = eConsole : role = eCommunications; 794 // Refresh the selected rendering endpoint device using role 795 ret = _GetDefaultDevice(eRender, role, &_ptrDeviceOut); 796 } 797 798 if (ret != 0 || (_ptrDeviceOut == NULL)) 799 { 800 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to initialize the rendering enpoint device"); 801 SAFE_RELEASE(_ptrDeviceOut); 802 return -1; 803 } 804 805 IAudioSessionManager* pManager = NULL; 806 ret = _ptrDeviceOut->Activate(__uuidof(IAudioSessionManager), 807 CLSCTX_ALL, 808 NULL, 809 (void**)&pManager); 810 if (ret != 0 || pManager == NULL) 811 { 812 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 813 " failed to initialize the render manager"); 814 SAFE_RELEASE(pManager); 815 return -1; 816 } 817 818 SAFE_RELEASE(_ptrRenderSimpleVolume); 819 ret = pManager->GetSimpleAudioVolume(NULL, FALSE, &_ptrRenderSimpleVolume); 820 if (ret != 0 || _ptrRenderSimpleVolume == NULL) 821 { 822 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 823 " failed to initialize the render simple volume"); 824 SAFE_RELEASE(pManager); 825 SAFE_RELEASE(_ptrRenderSimpleVolume); 826 return -1; 827 } 828 SAFE_RELEASE(pManager); 829 830 _speakerIsInitialized = true; 831 832 return 0; 833 } 834 835 // ---------------------------------------------------------------------------- 836 // InitMicrophone 837 // ---------------------------------------------------------------------------- 838 839 int32_t AudioDeviceWindowsCore::InitMicrophone() 840 { 841 842 CriticalSectionScoped lock(&_critSect); 843 844 if (_recording) 845 { 846 return -1; 847 } 848 849 if (_ptrDeviceIn == NULL) 850 { 851 return -1; 852 } 853 854 if (_usingInputDeviceIndex) 855 { 856 int16_t nDevices = RecordingDevices(); 857 if (_inputDeviceIndex > (nDevices - 1)) 858 { 859 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "current device selection is invalid => unable to initialize"); 860 return -1; 861 } 862 } 863 864 int32_t ret(0); 865 866 SAFE_RELEASE(_ptrDeviceIn); 867 if (_usingInputDeviceIndex) 868 { 869 // Refresh the selected capture endpoint device using current index 870 ret = _GetListDevice(eCapture, _inputDeviceIndex, &_ptrDeviceIn); 871 } 872 else 873 { 874 ERole role; 875 (_inputDevice == AudioDeviceModule::kDefaultDevice) ? role = eConsole : role = eCommunications; 876 // Refresh the selected capture endpoint device using role 877 ret = _GetDefaultDevice(eCapture, role, &_ptrDeviceIn); 878 } 879 880 if (ret != 0 || (_ptrDeviceIn == NULL)) 881 { 882 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to initialize the capturing enpoint device"); 883 SAFE_RELEASE(_ptrDeviceIn); 884 return -1; 885 } 886 887 ret = _ptrDeviceIn->Activate(__uuidof(IAudioEndpointVolume), 888 CLSCTX_ALL, 889 NULL, 890 reinterpret_cast<void **>(&_ptrCaptureVolume)); 891 if (ret != 0 || _ptrCaptureVolume == NULL) 892 { 893 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 894 " failed to initialize the capture volume"); 895 SAFE_RELEASE(_ptrCaptureVolume); 896 return -1; 897 } 898 899 _microphoneIsInitialized = true; 900 901 return 0; 902 } 903 904 // ---------------------------------------------------------------------------- 905 // SpeakerIsInitialized 906 // ---------------------------------------------------------------------------- 907 908 bool AudioDeviceWindowsCore::SpeakerIsInitialized() const 909 { 910 911 return (_speakerIsInitialized); 912 } 913 914 // ---------------------------------------------------------------------------- 915 // MicrophoneIsInitialized 916 // ---------------------------------------------------------------------------- 917 918 bool AudioDeviceWindowsCore::MicrophoneIsInitialized() const 919 { 920 921 return (_microphoneIsInitialized); 922 } 923 924 // ---------------------------------------------------------------------------- 925 // SpeakerVolumeIsAvailable 926 // ---------------------------------------------------------------------------- 927 928 int32_t AudioDeviceWindowsCore::SpeakerVolumeIsAvailable(bool& available) 929 { 930 931 CriticalSectionScoped lock(&_critSect); 932 933 if (_ptrDeviceOut == NULL) 934 { 935 return -1; 936 } 937 938 HRESULT hr = S_OK; 939 IAudioSessionManager* pManager = NULL; 940 ISimpleAudioVolume* pVolume = NULL; 941 942 hr = _ptrDeviceOut->Activate(__uuidof(IAudioSessionManager), CLSCTX_ALL, NULL, (void**)&pManager); 943 EXIT_ON_ERROR(hr); 944 945 hr = pManager->GetSimpleAudioVolume(NULL, FALSE, &pVolume); 946 EXIT_ON_ERROR(hr); 947 948 float volume(0.0f); 949 hr = pVolume->GetMasterVolume(&volume); 950 if (FAILED(hr)) 951 { 952 available = false; 953 } 954 available = true; 955 956 SAFE_RELEASE(pManager); 957 SAFE_RELEASE(pVolume); 958 959 return 0; 960 961 Exit: 962 _TraceCOMError(hr); 963 SAFE_RELEASE(pManager); 964 SAFE_RELEASE(pVolume); 965 return -1; 966 } 967 968 // ---------------------------------------------------------------------------- 969 // SetSpeakerVolume 970 // ---------------------------------------------------------------------------- 971 972 int32_t AudioDeviceWindowsCore::SetSpeakerVolume(uint32_t volume) 973 { 974 975 { 976 CriticalSectionScoped lock(&_critSect); 977 978 if (!_speakerIsInitialized) 979 { 980 return -1; 981 } 982 983 if (_ptrDeviceOut == NULL) 984 { 985 return -1; 986 } 987 } 988 989 if (volume < (uint32_t)MIN_CORE_SPEAKER_VOLUME || 990 volume > (uint32_t)MAX_CORE_SPEAKER_VOLUME) 991 { 992 return -1; 993 } 994 995 HRESULT hr = S_OK; 996 997 // scale input volume to valid range (0.0 to 1.0) 998 const float fLevel = (float)volume/MAX_CORE_SPEAKER_VOLUME; 999 _volumeMutex.Enter(); 1000 hr = _ptrRenderSimpleVolume->SetMasterVolume(fLevel,NULL); 1001 _volumeMutex.Leave(); 1002 EXIT_ON_ERROR(hr); 1003 1004 return 0; 1005 1006 Exit: 1007 _TraceCOMError(hr); 1008 return -1; 1009 } 1010 1011 // ---------------------------------------------------------------------------- 1012 // SpeakerVolume 1013 // ---------------------------------------------------------------------------- 1014 1015 int32_t AudioDeviceWindowsCore::SpeakerVolume(uint32_t& volume) const 1016 { 1017 1018 { 1019 CriticalSectionScoped lock(&_critSect); 1020 1021 if (!_speakerIsInitialized) 1022 { 1023 return -1; 1024 } 1025 1026 if (_ptrDeviceOut == NULL) 1027 { 1028 return -1; 1029 } 1030 } 1031 1032 HRESULT hr = S_OK; 1033 float fLevel(0.0f); 1034 1035 _volumeMutex.Enter(); 1036 hr = _ptrRenderSimpleVolume->GetMasterVolume(&fLevel); 1037 _volumeMutex.Leave(); 1038 EXIT_ON_ERROR(hr); 1039 1040 // scale input volume range [0.0,1.0] to valid output range 1041 volume = static_cast<uint32_t> (fLevel*MAX_CORE_SPEAKER_VOLUME); 1042 1043 return 0; 1044 1045 Exit: 1046 _TraceCOMError(hr); 1047 return -1; 1048 } 1049 1050 // ---------------------------------------------------------------------------- 1051 // SetWaveOutVolume 1052 // ---------------------------------------------------------------------------- 1053 1054 int32_t AudioDeviceWindowsCore::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) 1055 { 1056 return -1; 1057 } 1058 1059 // ---------------------------------------------------------------------------- 1060 // WaveOutVolume 1061 // ---------------------------------------------------------------------------- 1062 1063 int32_t AudioDeviceWindowsCore::WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const 1064 { 1065 return -1; 1066 } 1067 1068 // ---------------------------------------------------------------------------- 1069 // MaxSpeakerVolume 1070 // 1071 // The internal range for Core Audio is 0.0 to 1.0, where 0.0 indicates 1072 // silence and 1.0 indicates full volume (no attenuation). 1073 // We add our (webrtc-internal) own max level to match the Wave API and 1074 // how it is used today in VoE. 1075 // ---------------------------------------------------------------------------- 1076 1077 int32_t AudioDeviceWindowsCore::MaxSpeakerVolume(uint32_t& maxVolume) const 1078 { 1079 1080 if (!_speakerIsInitialized) 1081 { 1082 return -1; 1083 } 1084 1085 maxVolume = static_cast<uint32_t> (MAX_CORE_SPEAKER_VOLUME); 1086 1087 return 0; 1088 } 1089 1090 // ---------------------------------------------------------------------------- 1091 // MinSpeakerVolume 1092 // ---------------------------------------------------------------------------- 1093 1094 int32_t AudioDeviceWindowsCore::MinSpeakerVolume(uint32_t& minVolume) const 1095 { 1096 1097 if (!_speakerIsInitialized) 1098 { 1099 return -1; 1100 } 1101 1102 minVolume = static_cast<uint32_t> (MIN_CORE_SPEAKER_VOLUME); 1103 1104 return 0; 1105 } 1106 1107 // ---------------------------------------------------------------------------- 1108 // SpeakerVolumeStepSize 1109 // ---------------------------------------------------------------------------- 1110 1111 int32_t AudioDeviceWindowsCore::SpeakerVolumeStepSize(uint16_t& stepSize) const 1112 { 1113 1114 if (!_speakerIsInitialized) 1115 { 1116 return -1; 1117 } 1118 1119 stepSize = CORE_SPEAKER_VOLUME_STEP_SIZE; 1120 1121 return 0; 1122 } 1123 1124 // ---------------------------------------------------------------------------- 1125 // SpeakerMuteIsAvailable 1126 // ---------------------------------------------------------------------------- 1127 1128 int32_t AudioDeviceWindowsCore::SpeakerMuteIsAvailable(bool& available) 1129 { 1130 1131 CriticalSectionScoped lock(&_critSect); 1132 1133 if (_ptrDeviceOut == NULL) 1134 { 1135 return -1; 1136 } 1137 1138 HRESULT hr = S_OK; 1139 IAudioEndpointVolume* pVolume = NULL; 1140 1141 // Query the speaker system mute state. 1142 hr = _ptrDeviceOut->Activate(__uuidof(IAudioEndpointVolume), 1143 CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1144 EXIT_ON_ERROR(hr); 1145 1146 BOOL mute; 1147 hr = pVolume->GetMute(&mute); 1148 if (FAILED(hr)) 1149 available = false; 1150 else 1151 available = true; 1152 1153 SAFE_RELEASE(pVolume); 1154 1155 return 0; 1156 1157 Exit: 1158 _TraceCOMError(hr); 1159 SAFE_RELEASE(pVolume); 1160 return -1; 1161 } 1162 1163 // ---------------------------------------------------------------------------- 1164 // SetSpeakerMute 1165 // ---------------------------------------------------------------------------- 1166 1167 int32_t AudioDeviceWindowsCore::SetSpeakerMute(bool enable) 1168 { 1169 1170 CriticalSectionScoped lock(&_critSect); 1171 1172 if (!_speakerIsInitialized) 1173 { 1174 return -1; 1175 } 1176 1177 if (_ptrDeviceOut == NULL) 1178 { 1179 return -1; 1180 } 1181 1182 HRESULT hr = S_OK; 1183 IAudioEndpointVolume* pVolume = NULL; 1184 1185 // Set the speaker system mute state. 1186 hr = _ptrDeviceOut->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1187 EXIT_ON_ERROR(hr); 1188 1189 const BOOL mute(enable); 1190 hr = pVolume->SetMute(mute, NULL); 1191 EXIT_ON_ERROR(hr); 1192 1193 SAFE_RELEASE(pVolume); 1194 1195 return 0; 1196 1197 Exit: 1198 _TraceCOMError(hr); 1199 SAFE_RELEASE(pVolume); 1200 return -1; 1201 } 1202 1203 // ---------------------------------------------------------------------------- 1204 // SpeakerMute 1205 // ---------------------------------------------------------------------------- 1206 1207 int32_t AudioDeviceWindowsCore::SpeakerMute(bool& enabled) const 1208 { 1209 1210 if (!_speakerIsInitialized) 1211 { 1212 return -1; 1213 } 1214 1215 if (_ptrDeviceOut == NULL) 1216 { 1217 return -1; 1218 } 1219 1220 HRESULT hr = S_OK; 1221 IAudioEndpointVolume* pVolume = NULL; 1222 1223 // Query the speaker system mute state. 1224 hr = _ptrDeviceOut->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1225 EXIT_ON_ERROR(hr); 1226 1227 BOOL mute; 1228 hr = pVolume->GetMute(&mute); 1229 EXIT_ON_ERROR(hr); 1230 1231 enabled = (mute == TRUE) ? true : false; 1232 1233 SAFE_RELEASE(pVolume); 1234 1235 return 0; 1236 1237 Exit: 1238 _TraceCOMError(hr); 1239 SAFE_RELEASE(pVolume); 1240 return -1; 1241 } 1242 1243 // ---------------------------------------------------------------------------- 1244 // MicrophoneMuteIsAvailable 1245 // ---------------------------------------------------------------------------- 1246 1247 int32_t AudioDeviceWindowsCore::MicrophoneMuteIsAvailable(bool& available) 1248 { 1249 1250 CriticalSectionScoped lock(&_critSect); 1251 1252 if (_ptrDeviceIn == NULL) 1253 { 1254 return -1; 1255 } 1256 1257 HRESULT hr = S_OK; 1258 IAudioEndpointVolume* pVolume = NULL; 1259 1260 // Query the microphone system mute state. 1261 hr = _ptrDeviceIn->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1262 EXIT_ON_ERROR(hr); 1263 1264 BOOL mute; 1265 hr = pVolume->GetMute(&mute); 1266 if (FAILED(hr)) 1267 available = false; 1268 else 1269 available = true; 1270 1271 SAFE_RELEASE(pVolume); 1272 return 0; 1273 1274 Exit: 1275 _TraceCOMError(hr); 1276 SAFE_RELEASE(pVolume); 1277 return -1; 1278 } 1279 1280 // ---------------------------------------------------------------------------- 1281 // SetMicrophoneMute 1282 // ---------------------------------------------------------------------------- 1283 1284 int32_t AudioDeviceWindowsCore::SetMicrophoneMute(bool enable) 1285 { 1286 1287 if (!_microphoneIsInitialized) 1288 { 1289 return -1; 1290 } 1291 1292 if (_ptrDeviceIn == NULL) 1293 { 1294 return -1; 1295 } 1296 1297 HRESULT hr = S_OK; 1298 IAudioEndpointVolume* pVolume = NULL; 1299 1300 // Set the microphone system mute state. 1301 hr = _ptrDeviceIn->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1302 EXIT_ON_ERROR(hr); 1303 1304 const BOOL mute(enable); 1305 hr = pVolume->SetMute(mute, NULL); 1306 EXIT_ON_ERROR(hr); 1307 1308 SAFE_RELEASE(pVolume); 1309 return 0; 1310 1311 Exit: 1312 _TraceCOMError(hr); 1313 SAFE_RELEASE(pVolume); 1314 return -1; 1315 } 1316 1317 // ---------------------------------------------------------------------------- 1318 // MicrophoneMute 1319 // ---------------------------------------------------------------------------- 1320 1321 int32_t AudioDeviceWindowsCore::MicrophoneMute(bool& enabled) const 1322 { 1323 1324 if (!_microphoneIsInitialized) 1325 { 1326 return -1; 1327 } 1328 1329 HRESULT hr = S_OK; 1330 IAudioEndpointVolume* pVolume = NULL; 1331 1332 // Query the microphone system mute state. 1333 hr = _ptrDeviceIn->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1334 EXIT_ON_ERROR(hr); 1335 1336 BOOL mute; 1337 hr = pVolume->GetMute(&mute); 1338 EXIT_ON_ERROR(hr); 1339 1340 enabled = (mute == TRUE) ? true : false; 1341 1342 SAFE_RELEASE(pVolume); 1343 return 0; 1344 1345 Exit: 1346 _TraceCOMError(hr); 1347 SAFE_RELEASE(pVolume); 1348 return -1; 1349 } 1350 1351 // ---------------------------------------------------------------------------- 1352 // MicrophoneBoostIsAvailable 1353 // ---------------------------------------------------------------------------- 1354 1355 int32_t AudioDeviceWindowsCore::MicrophoneBoostIsAvailable(bool& available) 1356 { 1357 1358 available = false; 1359 return 0; 1360 } 1361 1362 // ---------------------------------------------------------------------------- 1363 // SetMicrophoneBoost 1364 // ---------------------------------------------------------------------------- 1365 1366 int32_t AudioDeviceWindowsCore::SetMicrophoneBoost(bool enable) 1367 { 1368 1369 if (!_microphoneIsInitialized) 1370 { 1371 return -1; 1372 } 1373 1374 return -1; 1375 } 1376 1377 // ---------------------------------------------------------------------------- 1378 // MicrophoneBoost 1379 // ---------------------------------------------------------------------------- 1380 1381 int32_t AudioDeviceWindowsCore::MicrophoneBoost(bool& enabled) const 1382 { 1383 1384 if (!_microphoneIsInitialized) 1385 { 1386 return -1; 1387 } 1388 1389 return -1; 1390 } 1391 1392 // ---------------------------------------------------------------------------- 1393 // StereoRecordingIsAvailable 1394 // ---------------------------------------------------------------------------- 1395 1396 int32_t AudioDeviceWindowsCore::StereoRecordingIsAvailable(bool& available) 1397 { 1398 1399 available = true; 1400 return 0; 1401 } 1402 1403 // ---------------------------------------------------------------------------- 1404 // SetStereoRecording 1405 // ---------------------------------------------------------------------------- 1406 1407 int32_t AudioDeviceWindowsCore::SetStereoRecording(bool enable) 1408 { 1409 1410 CriticalSectionScoped lock(&_critSect); 1411 1412 if (enable) 1413 { 1414 _recChannelsPrioList[0] = 2; // try stereo first 1415 _recChannelsPrioList[1] = 1; 1416 _recChannels = 2; 1417 } 1418 else 1419 { 1420 _recChannelsPrioList[0] = 1; // try mono first 1421 _recChannelsPrioList[1] = 2; 1422 _recChannels = 1; 1423 } 1424 1425 return 0; 1426 } 1427 1428 // ---------------------------------------------------------------------------- 1429 // StereoRecording 1430 // ---------------------------------------------------------------------------- 1431 1432 int32_t AudioDeviceWindowsCore::StereoRecording(bool& enabled) const 1433 { 1434 1435 if (_recChannels == 2) 1436 enabled = true; 1437 else 1438 enabled = false; 1439 1440 return 0; 1441 } 1442 1443 // ---------------------------------------------------------------------------- 1444 // StereoPlayoutIsAvailable 1445 // ---------------------------------------------------------------------------- 1446 1447 int32_t AudioDeviceWindowsCore::StereoPlayoutIsAvailable(bool& available) 1448 { 1449 1450 available = true; 1451 return 0; 1452 } 1453 1454 // ---------------------------------------------------------------------------- 1455 // SetStereoPlayout 1456 // ---------------------------------------------------------------------------- 1457 1458 int32_t AudioDeviceWindowsCore::SetStereoPlayout(bool enable) 1459 { 1460 1461 CriticalSectionScoped lock(&_critSect); 1462 1463 if (enable) 1464 { 1465 _playChannelsPrioList[0] = 2; // try stereo first 1466 _playChannelsPrioList[1] = 1; 1467 _playChannels = 2; 1468 } 1469 else 1470 { 1471 _playChannelsPrioList[0] = 1; // try mono first 1472 _playChannelsPrioList[1] = 2; 1473 _playChannels = 1; 1474 } 1475 1476 return 0; 1477 } 1478 1479 // ---------------------------------------------------------------------------- 1480 // StereoPlayout 1481 // ---------------------------------------------------------------------------- 1482 1483 int32_t AudioDeviceWindowsCore::StereoPlayout(bool& enabled) const 1484 { 1485 1486 if (_playChannels == 2) 1487 enabled = true; 1488 else 1489 enabled = false; 1490 1491 return 0; 1492 } 1493 1494 // ---------------------------------------------------------------------------- 1495 // SetAGC 1496 // ---------------------------------------------------------------------------- 1497 1498 int32_t AudioDeviceWindowsCore::SetAGC(bool enable) 1499 { 1500 CriticalSectionScoped lock(&_critSect); 1501 _AGC = enable; 1502 return 0; 1503 } 1504 1505 // ---------------------------------------------------------------------------- 1506 // AGC 1507 // ---------------------------------------------------------------------------- 1508 1509 bool AudioDeviceWindowsCore::AGC() const 1510 { 1511 CriticalSectionScoped lock(&_critSect); 1512 return _AGC; 1513 } 1514 1515 // ---------------------------------------------------------------------------- 1516 // MicrophoneVolumeIsAvailable 1517 // ---------------------------------------------------------------------------- 1518 1519 int32_t AudioDeviceWindowsCore::MicrophoneVolumeIsAvailable(bool& available) 1520 { 1521 1522 CriticalSectionScoped lock(&_critSect); 1523 1524 if (_ptrDeviceIn == NULL) 1525 { 1526 return -1; 1527 } 1528 1529 HRESULT hr = S_OK; 1530 IAudioEndpointVolume* pVolume = NULL; 1531 1532 hr = _ptrDeviceIn->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume)); 1533 EXIT_ON_ERROR(hr); 1534 1535 float volume(0.0f); 1536 hr = pVolume->GetMasterVolumeLevelScalar(&volume); 1537 if (FAILED(hr)) 1538 { 1539 available = false; 1540 } 1541 available = true; 1542 1543 SAFE_RELEASE(pVolume); 1544 return 0; 1545 1546 Exit: 1547 _TraceCOMError(hr); 1548 SAFE_RELEASE(pVolume); 1549 return -1; 1550 } 1551 1552 // ---------------------------------------------------------------------------- 1553 // SetMicrophoneVolume 1554 // ---------------------------------------------------------------------------- 1555 1556 int32_t AudioDeviceWindowsCore::SetMicrophoneVolume(uint32_t volume) 1557 { 1558 WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::SetMicrophoneVolume(volume=%u)", volume); 1559 1560 { 1561 CriticalSectionScoped lock(&_critSect); 1562 1563 if (!_microphoneIsInitialized) 1564 { 1565 return -1; 1566 } 1567 1568 if (_ptrDeviceIn == NULL) 1569 { 1570 return -1; 1571 } 1572 } 1573 1574 if (volume < static_cast<uint32_t>(MIN_CORE_MICROPHONE_VOLUME) || 1575 volume > static_cast<uint32_t>(MAX_CORE_MICROPHONE_VOLUME)) 1576 { 1577 return -1; 1578 } 1579 1580 HRESULT hr = S_OK; 1581 // scale input volume to valid range (0.0 to 1.0) 1582 const float fLevel = static_cast<float>(volume)/MAX_CORE_MICROPHONE_VOLUME; 1583 _volumeMutex.Enter(); 1584 _ptrCaptureVolume->SetMasterVolumeLevelScalar(fLevel, NULL); 1585 _volumeMutex.Leave(); 1586 EXIT_ON_ERROR(hr); 1587 1588 return 0; 1589 1590 Exit: 1591 _TraceCOMError(hr); 1592 return -1; 1593 } 1594 1595 // ---------------------------------------------------------------------------- 1596 // MicrophoneVolume 1597 // ---------------------------------------------------------------------------- 1598 1599 int32_t AudioDeviceWindowsCore::MicrophoneVolume(uint32_t& volume) const 1600 { 1601 { 1602 CriticalSectionScoped lock(&_critSect); 1603 1604 if (!_microphoneIsInitialized) 1605 { 1606 return -1; 1607 } 1608 1609 if (_ptrDeviceIn == NULL) 1610 { 1611 return -1; 1612 } 1613 } 1614 1615 HRESULT hr = S_OK; 1616 float fLevel(0.0f); 1617 volume = 0; 1618 _volumeMutex.Enter(); 1619 hr = _ptrCaptureVolume->GetMasterVolumeLevelScalar(&fLevel); 1620 _volumeMutex.Leave(); 1621 EXIT_ON_ERROR(hr); 1622 1623 // scale input volume range [0.0,1.0] to valid output range 1624 volume = static_cast<uint32_t> (fLevel*MAX_CORE_MICROPHONE_VOLUME); 1625 1626 return 0; 1627 1628 Exit: 1629 _TraceCOMError(hr); 1630 return -1; 1631 } 1632 1633 // ---------------------------------------------------------------------------- 1634 // MaxMicrophoneVolume 1635 // 1636 // The internal range for Core Audio is 0.0 to 1.0, where 0.0 indicates 1637 // silence and 1.0 indicates full volume (no attenuation). 1638 // We add our (webrtc-internal) own max level to match the Wave API and 1639 // how it is used today in VoE. 1640 // ---------------------------------------------------------------------------- 1641 1642 int32_t AudioDeviceWindowsCore::MaxMicrophoneVolume(uint32_t& maxVolume) const 1643 { 1644 WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); 1645 1646 if (!_microphoneIsInitialized) 1647 { 1648 return -1; 1649 } 1650 1651 maxVolume = static_cast<uint32_t> (MAX_CORE_MICROPHONE_VOLUME); 1652 1653 return 0; 1654 } 1655 1656 // ---------------------------------------------------------------------------- 1657 // MinMicrophoneVolume 1658 // ---------------------------------------------------------------------------- 1659 1660 int32_t AudioDeviceWindowsCore::MinMicrophoneVolume(uint32_t& minVolume) const 1661 { 1662 1663 if (!_microphoneIsInitialized) 1664 { 1665 return -1; 1666 } 1667 1668 minVolume = static_cast<uint32_t> (MIN_CORE_MICROPHONE_VOLUME); 1669 1670 return 0; 1671 } 1672 1673 // ---------------------------------------------------------------------------- 1674 // MicrophoneVolumeStepSize 1675 // ---------------------------------------------------------------------------- 1676 1677 int32_t AudioDeviceWindowsCore::MicrophoneVolumeStepSize(uint16_t& stepSize) const 1678 { 1679 1680 if (!_microphoneIsInitialized) 1681 { 1682 return -1; 1683 } 1684 1685 stepSize = CORE_MICROPHONE_VOLUME_STEP_SIZE; 1686 1687 return 0; 1688 } 1689 1690 // ---------------------------------------------------------------------------- 1691 // PlayoutDevices 1692 // ---------------------------------------------------------------------------- 1693 1694 int16_t AudioDeviceWindowsCore::PlayoutDevices() 1695 { 1696 1697 CriticalSectionScoped lock(&_critSect); 1698 1699 if (_RefreshDeviceList(eRender) != -1) 1700 { 1701 return (_DeviceListCount(eRender)); 1702 } 1703 1704 return -1; 1705 } 1706 1707 // ---------------------------------------------------------------------------- 1708 // SetPlayoutDevice I (II) 1709 // ---------------------------------------------------------------------------- 1710 1711 int32_t AudioDeviceWindowsCore::SetPlayoutDevice(uint16_t index) 1712 { 1713 1714 if (_playIsInitialized) 1715 { 1716 return -1; 1717 } 1718 1719 // Get current number of available rendering endpoint devices and refresh the rendering collection. 1720 UINT nDevices = PlayoutDevices(); 1721 1722 if (index < 0 || index > (nDevices-1)) 1723 { 1724 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device index is out of range [0,%u]", (nDevices-1)); 1725 return -1; 1726 } 1727 1728 CriticalSectionScoped lock(&_critSect); 1729 1730 HRESULT hr(S_OK); 1731 1732 assert(_ptrRenderCollection != NULL); 1733 1734 // Select an endpoint rendering device given the specified index 1735 SAFE_RELEASE(_ptrDeviceOut); 1736 hr = _ptrRenderCollection->Item( 1737 index, 1738 &_ptrDeviceOut); 1739 if (FAILED(hr)) 1740 { 1741 _TraceCOMError(hr); 1742 SAFE_RELEASE(_ptrDeviceOut); 1743 return -1; 1744 } 1745 1746 WCHAR szDeviceName[MAX_PATH]; 1747 const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; 1748 1749 // Get the endpoint device's friendly-name 1750 if (_GetDeviceName(_ptrDeviceOut, szDeviceName, bufferLen) == 0) 1751 { 1752 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "friendly name: \"%S\"", szDeviceName); 1753 } 1754 1755 _usingOutputDeviceIndex = true; 1756 _outputDeviceIndex = index; 1757 1758 return 0; 1759 } 1760 1761 // ---------------------------------------------------------------------------- 1762 // SetPlayoutDevice II (II) 1763 // ---------------------------------------------------------------------------- 1764 1765 int32_t AudioDeviceWindowsCore::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device) 1766 { 1767 if (_playIsInitialized) 1768 { 1769 return -1; 1770 } 1771 1772 ERole role(eCommunications); 1773 1774 if (device == AudioDeviceModule::kDefaultDevice) 1775 { 1776 role = eConsole; 1777 } 1778 else if (device == AudioDeviceModule::kDefaultCommunicationDevice) 1779 { 1780 role = eCommunications; 1781 } 1782 1783 CriticalSectionScoped lock(&_critSect); 1784 1785 // Refresh the list of rendering endpoint devices 1786 _RefreshDeviceList(eRender); 1787 1788 HRESULT hr(S_OK); 1789 1790 assert(_ptrEnumerator != NULL); 1791 1792 // Select an endpoint rendering device given the specified role 1793 SAFE_RELEASE(_ptrDeviceOut); 1794 hr = _ptrEnumerator->GetDefaultAudioEndpoint( 1795 eRender, 1796 role, 1797 &_ptrDeviceOut); 1798 if (FAILED(hr)) 1799 { 1800 _TraceCOMError(hr); 1801 SAFE_RELEASE(_ptrDeviceOut); 1802 return -1; 1803 } 1804 1805 WCHAR szDeviceName[MAX_PATH]; 1806 const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; 1807 1808 // Get the endpoint device's friendly-name 1809 if (_GetDeviceName(_ptrDeviceOut, szDeviceName, bufferLen) == 0) 1810 { 1811 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "friendly name: \"%S\"", szDeviceName); 1812 } 1813 1814 _usingOutputDeviceIndex = false; 1815 _outputDevice = device; 1816 1817 return 0; 1818 } 1819 1820 // ---------------------------------------------------------------------------- 1821 // PlayoutDeviceName 1822 // ---------------------------------------------------------------------------- 1823 1824 int32_t AudioDeviceWindowsCore::PlayoutDeviceName( 1825 uint16_t index, 1826 char name[kAdmMaxDeviceNameSize], 1827 char guid[kAdmMaxGuidSize]) 1828 { 1829 1830 bool defaultCommunicationDevice(false); 1831 const int16_t nDevices(PlayoutDevices()); // also updates the list of devices 1832 1833 // Special fix for the case when the user selects '-1' as index (<=> Default Communication Device) 1834 if (index == (uint16_t)(-1)) 1835 { 1836 defaultCommunicationDevice = true; 1837 index = 0; 1838 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Default Communication endpoint device will be used"); 1839 } 1840 1841 if ((index > (nDevices-1)) || (name == NULL)) 1842 { 1843 return -1; 1844 } 1845 1846 memset(name, 0, kAdmMaxDeviceNameSize); 1847 1848 if (guid != NULL) 1849 { 1850 memset(guid, 0, kAdmMaxGuidSize); 1851 } 1852 1853 CriticalSectionScoped lock(&_critSect); 1854 1855 int32_t ret(-1); 1856 WCHAR szDeviceName[MAX_PATH]; 1857 const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; 1858 1859 // Get the endpoint device's friendly-name 1860 if (defaultCommunicationDevice) 1861 { 1862 ret = _GetDefaultDeviceName(eRender, eCommunications, szDeviceName, bufferLen); 1863 } 1864 else 1865 { 1866 ret = _GetListDeviceName(eRender, index, szDeviceName, bufferLen); 1867 } 1868 1869 if (ret == 0) 1870 { 1871 // Convert the endpoint device's friendly-name to UTF-8 1872 if (WideCharToMultiByte(CP_UTF8, 0, szDeviceName, -1, name, kAdmMaxDeviceNameSize, NULL, NULL) == 0) 1873 { 1874 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d", GetLastError()); 1875 } 1876 } 1877 1878 // Get the endpoint ID string (uniquely identifies the device among all audio endpoint devices) 1879 if (defaultCommunicationDevice) 1880 { 1881 ret = _GetDefaultDeviceID(eRender, eCommunications, szDeviceName, bufferLen); 1882 } 1883 else 1884 { 1885 ret = _GetListDeviceID(eRender, index, szDeviceName, bufferLen); 1886 } 1887 1888 if (guid != NULL && ret == 0) 1889 { 1890 // Convert the endpoint device's ID string to UTF-8 1891 if (WideCharToMultiByte(CP_UTF8, 0, szDeviceName, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0) 1892 { 1893 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d", GetLastError()); 1894 } 1895 } 1896 1897 return ret; 1898 } 1899 1900 // ---------------------------------------------------------------------------- 1901 // RecordingDeviceName 1902 // ---------------------------------------------------------------------------- 1903 1904 int32_t AudioDeviceWindowsCore::RecordingDeviceName( 1905 uint16_t index, 1906 char name[kAdmMaxDeviceNameSize], 1907 char guid[kAdmMaxGuidSize]) 1908 { 1909 1910 bool defaultCommunicationDevice(false); 1911 const int16_t nDevices(RecordingDevices()); // also updates the list of devices 1912 1913 // Special fix for the case when the user selects '-1' as index (<=> Default Communication Device) 1914 if (index == (uint16_t)(-1)) 1915 { 1916 defaultCommunicationDevice = true; 1917 index = 0; 1918 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Default Communication endpoint device will be used"); 1919 } 1920 1921 if ((index > (nDevices-1)) || (name == NULL)) 1922 { 1923 return -1; 1924 } 1925 1926 memset(name, 0, kAdmMaxDeviceNameSize); 1927 1928 if (guid != NULL) 1929 { 1930 memset(guid, 0, kAdmMaxGuidSize); 1931 } 1932 1933 CriticalSectionScoped lock(&_critSect); 1934 1935 int32_t ret(-1); 1936 WCHAR szDeviceName[MAX_PATH]; 1937 const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; 1938 1939 // Get the endpoint device's friendly-name 1940 if (defaultCommunicationDevice) 1941 { 1942 ret = _GetDefaultDeviceName(eCapture, eCommunications, szDeviceName, bufferLen); 1943 } 1944 else 1945 { 1946 ret = _GetListDeviceName(eCapture, index, szDeviceName, bufferLen); 1947 } 1948 1949 if (ret == 0) 1950 { 1951 // Convert the endpoint device's friendly-name to UTF-8 1952 if (WideCharToMultiByte(CP_UTF8, 0, szDeviceName, -1, name, kAdmMaxDeviceNameSize, NULL, NULL) == 0) 1953 { 1954 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d", GetLastError()); 1955 } 1956 } 1957 1958 // Get the endpoint ID string (uniquely identifies the device among all audio endpoint devices) 1959 if (defaultCommunicationDevice) 1960 { 1961 ret = _GetDefaultDeviceID(eCapture, eCommunications, szDeviceName, bufferLen); 1962 } 1963 else 1964 { 1965 ret = _GetListDeviceID(eCapture, index, szDeviceName, bufferLen); 1966 } 1967 1968 if (guid != NULL && ret == 0) 1969 { 1970 // Convert the endpoint device's ID string to UTF-8 1971 if (WideCharToMultiByte(CP_UTF8, 0, szDeviceName, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0) 1972 { 1973 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d", GetLastError()); 1974 } 1975 } 1976 1977 return ret; 1978 } 1979 1980 // ---------------------------------------------------------------------------- 1981 // RecordingDevices 1982 // ---------------------------------------------------------------------------- 1983 1984 int16_t AudioDeviceWindowsCore::RecordingDevices() 1985 { 1986 1987 CriticalSectionScoped lock(&_critSect); 1988 1989 if (_RefreshDeviceList(eCapture) != -1) 1990 { 1991 return (_DeviceListCount(eCapture)); 1992 } 1993 1994 return -1; 1995 } 1996 1997 // ---------------------------------------------------------------------------- 1998 // SetRecordingDevice I (II) 1999 // ---------------------------------------------------------------------------- 2000 2001 int32_t AudioDeviceWindowsCore::SetRecordingDevice(uint16_t index) 2002 { 2003 2004 if (_recIsInitialized) 2005 { 2006 return -1; 2007 } 2008 2009 // Get current number of available capture endpoint devices and refresh the capture collection. 2010 UINT nDevices = RecordingDevices(); 2011 2012 if (index < 0 || index > (nDevices-1)) 2013 { 2014 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device index is out of range [0,%u]", (nDevices-1)); 2015 return -1; 2016 } 2017 2018 CriticalSectionScoped lock(&_critSect); 2019 2020 HRESULT hr(S_OK); 2021 2022 assert(_ptrCaptureCollection != NULL); 2023 2024 // Select an endpoint capture device given the specified index 2025 SAFE_RELEASE(_ptrDeviceIn); 2026 hr = _ptrCaptureCollection->Item( 2027 index, 2028 &_ptrDeviceIn); 2029 if (FAILED(hr)) 2030 { 2031 _TraceCOMError(hr); 2032 SAFE_RELEASE(_ptrDeviceIn); 2033 return -1; 2034 } 2035 2036 WCHAR szDeviceName[MAX_PATH]; 2037 const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; 2038 2039 // Get the endpoint device's friendly-name 2040 if (_GetDeviceName(_ptrDeviceIn, szDeviceName, bufferLen) == 0) 2041 { 2042 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "friendly name: \"%S\"", szDeviceName); 2043 } 2044 2045 _usingInputDeviceIndex = true; 2046 _inputDeviceIndex = index; 2047 2048 return 0; 2049 } 2050 2051 // ---------------------------------------------------------------------------- 2052 // SetRecordingDevice II (II) 2053 // ---------------------------------------------------------------------------- 2054 2055 int32_t AudioDeviceWindowsCore::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device) 2056 { 2057 if (_recIsInitialized) 2058 { 2059 return -1; 2060 } 2061 2062 ERole role(eCommunications); 2063 2064 if (device == AudioDeviceModule::kDefaultDevice) 2065 { 2066 role = eConsole; 2067 } 2068 else if (device == AudioDeviceModule::kDefaultCommunicationDevice) 2069 { 2070 role = eCommunications; 2071 } 2072 2073 CriticalSectionScoped lock(&_critSect); 2074 2075 // Refresh the list of capture endpoint devices 2076 _RefreshDeviceList(eCapture); 2077 2078 HRESULT hr(S_OK); 2079 2080 assert(_ptrEnumerator != NULL); 2081 2082 // Select an endpoint capture device given the specified role 2083 SAFE_RELEASE(_ptrDeviceIn); 2084 hr = _ptrEnumerator->GetDefaultAudioEndpoint( 2085 eCapture, 2086 role, 2087 &_ptrDeviceIn); 2088 if (FAILED(hr)) 2089 { 2090 _TraceCOMError(hr); 2091 SAFE_RELEASE(_ptrDeviceIn); 2092 return -1; 2093 } 2094 2095 WCHAR szDeviceName[MAX_PATH]; 2096 const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; 2097 2098 // Get the endpoint device's friendly-name 2099 if (_GetDeviceName(_ptrDeviceIn, szDeviceName, bufferLen) == 0) 2100 { 2101 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "friendly name: \"%S\"", szDeviceName); 2102 } 2103 2104 _usingInputDeviceIndex = false; 2105 _inputDevice = device; 2106 2107 return 0; 2108 } 2109 2110 // ---------------------------------------------------------------------------- 2111 // PlayoutIsAvailable 2112 // ---------------------------------------------------------------------------- 2113 2114 int32_t AudioDeviceWindowsCore::PlayoutIsAvailable(bool& available) 2115 { 2116 2117 available = false; 2118 2119 // Try to initialize the playout side 2120 int32_t res = InitPlayout(); 2121 2122 // Cancel effect of initialization 2123 StopPlayout(); 2124 2125 if (res != -1) 2126 { 2127 available = true; 2128 } 2129 2130 return 0; 2131 } 2132 2133 // ---------------------------------------------------------------------------- 2134 // RecordingIsAvailable 2135 // ---------------------------------------------------------------------------- 2136 2137 int32_t AudioDeviceWindowsCore::RecordingIsAvailable(bool& available) 2138 { 2139 2140 available = false; 2141 2142 // Try to initialize the recording side 2143 int32_t res = InitRecording(); 2144 2145 // Cancel effect of initialization 2146 StopRecording(); 2147 2148 if (res != -1) 2149 { 2150 available = true; 2151 } 2152 2153 return 0; 2154 } 2155 2156 // ---------------------------------------------------------------------------- 2157 // InitPlayout 2158 // ---------------------------------------------------------------------------- 2159 2160 int32_t AudioDeviceWindowsCore::InitPlayout() 2161 { 2162 2163 CriticalSectionScoped lock(&_critSect); 2164 2165 if (_playing) 2166 { 2167 return -1; 2168 } 2169 2170 if (_playIsInitialized) 2171 { 2172 return 0; 2173 } 2174 2175 if (_ptrDeviceOut == NULL) 2176 { 2177 return -1; 2178 } 2179 2180 // Initialize the speaker (devices might have been added or removed) 2181 if (InitSpeaker() == -1) 2182 { 2183 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "InitSpeaker() failed"); 2184 } 2185 2186 // Ensure that the updated rendering endpoint device is valid 2187 if (_ptrDeviceOut == NULL) 2188 { 2189 return -1; 2190 } 2191 2192 if (_builtInAecEnabled && _recIsInitialized) 2193 { 2194 // Ensure the correct render device is configured in case 2195 // InitRecording() was called before InitPlayout(). 2196 if (SetDMOProperties() == -1) 2197 { 2198 return -1; 2199 } 2200 } 2201 2202 HRESULT hr = S_OK; 2203 WAVEFORMATEX* pWfxOut = NULL; 2204 WAVEFORMATEX Wfx; 2205 WAVEFORMATEX* pWfxClosestMatch = NULL; 2206 2207 // Create COM object with IAudioClient interface. 2208 SAFE_RELEASE(_ptrClientOut); 2209 hr = _ptrDeviceOut->Activate( 2210 __uuidof(IAudioClient), 2211 CLSCTX_ALL, 2212 NULL, 2213 (void**)&_ptrClientOut); 2214 EXIT_ON_ERROR(hr); 2215 2216 // Retrieve the stream format that the audio engine uses for its internal 2217 // processing (mixing) of shared-mode streams. 2218 hr = _ptrClientOut->GetMixFormat(&pWfxOut); 2219 if (SUCCEEDED(hr)) 2220 { 2221 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Audio Engine's current rendering mix format:"); 2222 // format type 2223 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wFormatTag : 0x%X (%u)", pWfxOut->wFormatTag, pWfxOut->wFormatTag); 2224 // number of channels (i.e. mono, stereo...) 2225 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nChannels : %d", pWfxOut->nChannels); 2226 // sample rate 2227 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nSamplesPerSec : %d", pWfxOut->nSamplesPerSec); 2228 // for buffer estimation 2229 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nAvgBytesPerSec: %d", pWfxOut->nAvgBytesPerSec); 2230 // block size of data 2231 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nBlockAlign : %d", pWfxOut->nBlockAlign); 2232 // number of bits per sample of mono data 2233 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wBitsPerSample : %d", pWfxOut->wBitsPerSample); 2234 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "cbSize : %d", pWfxOut->cbSize); 2235 } 2236 2237 // Set wave format 2238 Wfx.wFormatTag = WAVE_FORMAT_PCM; 2239 Wfx.wBitsPerSample = 16; 2240 Wfx.cbSize = 0; 2241 2242 const int freqs[] = {48000, 44100, 16000, 96000, 32000, 8000}; 2243 hr = S_FALSE; 2244 2245 // Iterate over frequencies and channels, in order of priority 2246 for (int freq = 0; freq < sizeof(freqs)/sizeof(freqs[0]); freq++) 2247 { 2248 for (int chan = 0; chan < sizeof(_playChannelsPrioList)/sizeof(_playChannelsPrioList[0]); chan++) 2249 { 2250 Wfx.nChannels = _playChannelsPrioList[chan]; 2251 Wfx.nSamplesPerSec = freqs[freq]; 2252 Wfx.nBlockAlign = Wfx.nChannels * Wfx.wBitsPerSample / 8; 2253 Wfx.nAvgBytesPerSec = Wfx.nSamplesPerSec * Wfx.nBlockAlign; 2254 // If the method succeeds and the audio endpoint device supports the specified stream format, 2255 // it returns S_OK. If the method succeeds and provides a closest match to the specified format, 2256 // it returns S_FALSE. 2257 hr = _ptrClientOut->IsFormatSupported( 2258 AUDCLNT_SHAREMODE_SHARED, 2259 &Wfx, 2260 &pWfxClosestMatch); 2261 if (hr == S_OK) 2262 { 2263 break; 2264 } 2265 else 2266 { 2267 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nChannels=%d, nSamplesPerSec=%d is not supported", 2268 Wfx.nChannels, Wfx.nSamplesPerSec); 2269 } 2270 } 2271 if (hr == S_OK) 2272 break; 2273 } 2274 2275 // TODO(andrew): what happens in the event of failure in the above loop? 2276 // Is _ptrClientOut->Initialize expected to fail? 2277 // Same in InitRecording(). 2278 if (hr == S_OK) 2279 { 2280 _playAudioFrameSize = Wfx.nBlockAlign; 2281 _playBlockSize = Wfx.nSamplesPerSec/100; 2282 _playSampleRate = Wfx.nSamplesPerSec; 2283 _devicePlaySampleRate = Wfx.nSamplesPerSec; // The device itself continues to run at 44.1 kHz. 2284 _devicePlayBlockSize = Wfx.nSamplesPerSec/100; 2285 _playChannels = Wfx.nChannels; 2286 2287 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "VoE selected this rendering format:"); 2288 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wFormatTag : 0x%X (%u)", Wfx.wFormatTag, Wfx.wFormatTag); 2289 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nChannels : %d", Wfx.nChannels); 2290 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nSamplesPerSec : %d", Wfx.nSamplesPerSec); 2291 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nAvgBytesPerSec : %d", Wfx.nAvgBytesPerSec); 2292 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nBlockAlign : %d", Wfx.nBlockAlign); 2293 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wBitsPerSample : %d", Wfx.wBitsPerSample); 2294 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "cbSize : %d", Wfx.cbSize); 2295 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Additional settings:"); 2296 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_playAudioFrameSize: %d", _playAudioFrameSize); 2297 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_playBlockSize : %d", _playBlockSize); 2298 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_playChannels : %d", _playChannels); 2299 } 2300 2301 // Create a rendering stream. 2302 // 2303 // **************************************************************************** 2304 // For a shared-mode stream that uses event-driven buffering, the caller must 2305 // set both hnsPeriodicity and hnsBufferDuration to 0. The Initialize method 2306 // determines how large a buffer to allocate based on the scheduling period 2307 // of the audio engine. Although the client's buffer processing thread is 2308 // event driven, the basic buffer management process, as described previously, 2309 // is unaltered. 2310 // Each time the thread awakens, it should call IAudioClient::GetCurrentPadding 2311 // to determine how much data to write to a rendering buffer or read from a capture 2312 // buffer. In contrast to the two buffers that the Initialize method allocates 2313 // for an exclusive-mode stream that uses event-driven buffering, a shared-mode 2314 // stream requires a single buffer. 2315 // **************************************************************************** 2316 // 2317 REFERENCE_TIME hnsBufferDuration = 0; // ask for minimum buffer size (default) 2318 if (_devicePlaySampleRate == 44100) 2319 { 2320 // Ask for a larger buffer size (30ms) when using 44.1kHz as render rate. 2321 // There seems to be a larger risk of underruns for 44.1 compared 2322 // with the default rate (48kHz). When using default, we set the requested 2323 // buffer duration to 0, which sets the buffer to the minimum size 2324 // required by the engine thread. The actual buffer size can then be 2325 // read by GetBufferSize() and it is 20ms on most machines. 2326 hnsBufferDuration = 30*10000; 2327 } 2328 hr = _ptrClientOut->Initialize( 2329 AUDCLNT_SHAREMODE_SHARED, // share Audio Engine with other applications 2330 AUDCLNT_STREAMFLAGS_EVENTCALLBACK, // processing of the audio buffer by the client will be event driven 2331 hnsBufferDuration, // requested buffer capacity as a time value (in 100-nanosecond units) 2332 0, // periodicity 2333 &Wfx, // selected wave format 2334 NULL); // session GUID 2335 2336 if (FAILED(hr)) 2337 { 2338 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "IAudioClient::Initialize() failed:"); 2339 if (pWfxClosestMatch != NULL) 2340 { 2341 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "closest mix format: #channels=%d, samples/sec=%d, bits/sample=%d", 2342 pWfxClosestMatch->nChannels, pWfxClosestMatch->nSamplesPerSec, pWfxClosestMatch->wBitsPerSample); 2343 } 2344 else 2345 { 2346 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "no format suggested"); 2347 } 2348 } 2349 EXIT_ON_ERROR(hr); 2350 2351 if (_ptrAudioBuffer) 2352 { 2353 // Update the audio buffer with the selected parameters 2354 _ptrAudioBuffer->SetPlayoutSampleRate(_playSampleRate); 2355 _ptrAudioBuffer->SetPlayoutChannels((uint8_t)_playChannels); 2356 } 2357 else 2358 { 2359 // We can enter this state during CoreAudioIsSupported() when no AudioDeviceImplementation 2360 // has been created, hence the AudioDeviceBuffer does not exist. 2361 // It is OK to end up here since we don't initiate any media in CoreAudioIsSupported(). 2362 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceBuffer must be attached before streaming can start"); 2363 } 2364 2365 // Get the actual size of the shared (endpoint buffer). 2366 // Typical value is 960 audio frames <=> 20ms @ 48kHz sample rate. 2367 UINT bufferFrameCount(0); 2368 hr = _ptrClientOut->GetBufferSize( 2369 &bufferFrameCount); 2370 if (SUCCEEDED(hr)) 2371 { 2372 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "IAudioClient::GetBufferSize() => %u (<=> %u bytes)", 2373 bufferFrameCount, bufferFrameCount*_playAudioFrameSize); 2374 } 2375 2376 // Set the event handle that the system signals when an audio buffer is ready 2377 // to be processed by the client. 2378 hr = _ptrClientOut->SetEventHandle( 2379 _hRenderSamplesReadyEvent); 2380 EXIT_ON_ERROR(hr); 2381 2382 // Get an IAudioRenderClient interface. 2383 SAFE_RELEASE(_ptrRenderClient); 2384 hr = _ptrClientOut->GetService( 2385 __uuidof(IAudioRenderClient), 2386 (void**)&_ptrRenderClient); 2387 EXIT_ON_ERROR(hr); 2388 2389 // Mark playout side as initialized 2390 _playIsInitialized = true; 2391 2392 CoTaskMemFree(pWfxOut); 2393 CoTaskMemFree(pWfxClosestMatch); 2394 2395 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "render side is now initialized"); 2396 return 0; 2397 2398 Exit: 2399 _TraceCOMError(hr); 2400 CoTaskMemFree(pWfxOut); 2401 CoTaskMemFree(pWfxClosestMatch); 2402 SAFE_RELEASE(_ptrClientOut); 2403 SAFE_RELEASE(_ptrRenderClient); 2404 return -1; 2405 } 2406 2407 // Capture initialization when the built-in AEC DirectX Media Object (DMO) is 2408 // used. Called from InitRecording(), most of which is skipped over. The DMO 2409 // handles device initialization itself. 2410 // Reference: http://msdn.microsoft.com/en-us/library/ff819492(v=vs.85).aspx 2411 int32_t AudioDeviceWindowsCore::InitRecordingDMO() 2412 { 2413 assert(_builtInAecEnabled); 2414 assert(_dmo != NULL); 2415 2416 if (SetDMOProperties() == -1) 2417 { 2418 return -1; 2419 } 2420 2421 DMO_MEDIA_TYPE mt = {0}; 2422 HRESULT hr = MoInitMediaType(&mt, sizeof(WAVEFORMATEX)); 2423 if (FAILED(hr)) 2424 { 2425 MoFreeMediaType(&mt); 2426 _TraceCOMError(hr); 2427 return -1; 2428 } 2429 mt.majortype = MEDIATYPE_Audio; 2430 mt.subtype = MEDIASUBTYPE_PCM; 2431 mt.formattype = FORMAT_WaveFormatEx; 2432 2433 // Supported formats 2434 // nChannels: 1 (in AEC-only mode) 2435 // nSamplesPerSec: 8000, 11025, 16000, 22050 2436 // wBitsPerSample: 16 2437 WAVEFORMATEX* ptrWav = reinterpret_cast<WAVEFORMATEX*>(mt.pbFormat); 2438 ptrWav->wFormatTag = WAVE_FORMAT_PCM; 2439 ptrWav->nChannels = 1; 2440 // 16000 is the highest we can support with our resampler. 2441 ptrWav->nSamplesPerSec = 16000; 2442 ptrWav->nAvgBytesPerSec = 32000; 2443 ptrWav->nBlockAlign = 2; 2444 ptrWav->wBitsPerSample = 16; 2445 ptrWav->cbSize = 0; 2446 2447 // Set the VoE format equal to the AEC output format. 2448 _recAudioFrameSize = ptrWav->nBlockAlign; 2449 _recSampleRate = ptrWav->nSamplesPerSec; 2450 _recBlockSize = ptrWav->nSamplesPerSec / 100; 2451 _recChannels = ptrWav->nChannels; 2452 2453 // Set the DMO output format parameters. 2454 hr = _dmo->SetOutputType(kAecCaptureStreamIndex, &mt, 0); 2455 MoFreeMediaType(&mt); 2456 if (FAILED(hr)) 2457 { 2458 _TraceCOMError(hr); 2459 return -1; 2460 } 2461 2462 if (_ptrAudioBuffer) 2463 { 2464 _ptrAudioBuffer->SetRecordingSampleRate(_recSampleRate); 2465 _ptrAudioBuffer->SetRecordingChannels(_recChannels); 2466 } 2467 else 2468 { 2469 // Refer to InitRecording() for comments. 2470 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2471 "AudioDeviceBuffer must be attached before streaming can start"); 2472 } 2473 2474 _mediaBuffer = new MediaBufferImpl(_recBlockSize * _recAudioFrameSize); 2475 2476 // Optional, but if called, must be after media types are set. 2477 hr = _dmo->AllocateStreamingResources(); 2478 if (FAILED(hr)) 2479 { 2480 _TraceCOMError(hr); 2481 return -1; 2482 } 2483 2484 _recIsInitialized = true; 2485 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2486 "Capture side is now initialized"); 2487 2488 return 0; 2489 } 2490 2491 // ---------------------------------------------------------------------------- 2492 // InitRecording 2493 // ---------------------------------------------------------------------------- 2494 2495 int32_t AudioDeviceWindowsCore::InitRecording() 2496 { 2497 2498 CriticalSectionScoped lock(&_critSect); 2499 2500 if (_recording) 2501 { 2502 return -1; 2503 } 2504 2505 if (_recIsInitialized) 2506 { 2507 return 0; 2508 } 2509 2510 if (QueryPerformanceFrequency(&_perfCounterFreq) == 0) 2511 { 2512 return -1; 2513 } 2514 _perfCounterFactor = 10000000.0 / (double)_perfCounterFreq.QuadPart; 2515 2516 if (_ptrDeviceIn == NULL) 2517 { 2518 return -1; 2519 } 2520 2521 // Initialize the microphone (devices might have been added or removed) 2522 if (InitMicrophone() == -1) 2523 { 2524 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "InitMicrophone() failed"); 2525 } 2526 2527 // Ensure that the updated capturing endpoint device is valid 2528 if (_ptrDeviceIn == NULL) 2529 { 2530 return -1; 2531 } 2532 2533 if (_builtInAecEnabled) 2534 { 2535 // The DMO will configure the capture device. 2536 return InitRecordingDMO(); 2537 } 2538 2539 HRESULT hr = S_OK; 2540 WAVEFORMATEX* pWfxIn = NULL; 2541 WAVEFORMATEX Wfx; 2542 WAVEFORMATEX* pWfxClosestMatch = NULL; 2543 2544 // Create COM object with IAudioClient interface. 2545 SAFE_RELEASE(_ptrClientIn); 2546 hr = _ptrDeviceIn->Activate( 2547 __uuidof(IAudioClient), 2548 CLSCTX_ALL, 2549 NULL, 2550 (void**)&_ptrClientIn); 2551 EXIT_ON_ERROR(hr); 2552 2553 // Retrieve the stream format that the audio engine uses for its internal 2554 // processing (mixing) of shared-mode streams. 2555 hr = _ptrClientIn->GetMixFormat(&pWfxIn); 2556 if (SUCCEEDED(hr)) 2557 { 2558 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Audio Engine's current capturing mix format:"); 2559 // format type 2560 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wFormatTag : 0x%X (%u)", pWfxIn->wFormatTag, pWfxIn->wFormatTag); 2561 // number of channels (i.e. mono, stereo...) 2562 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nChannels : %d", pWfxIn->nChannels); 2563 // sample rate 2564 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nSamplesPerSec : %d", pWfxIn->nSamplesPerSec); 2565 // for buffer estimation 2566 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nAvgBytesPerSec: %d", pWfxIn->nAvgBytesPerSec); 2567 // block size of data 2568 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nBlockAlign : %d", pWfxIn->nBlockAlign); 2569 // number of bits per sample of mono data 2570 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wBitsPerSample : %d", pWfxIn->wBitsPerSample); 2571 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "cbSize : %d", pWfxIn->cbSize); 2572 } 2573 2574 // Set wave format 2575 Wfx.wFormatTag = WAVE_FORMAT_PCM; 2576 Wfx.wBitsPerSample = 16; 2577 Wfx.cbSize = 0; 2578 2579 const int freqs[6] = {48000, 44100, 16000, 96000, 32000, 8000}; 2580 hr = S_FALSE; 2581 2582 // Iterate over frequencies and channels, in order of priority 2583 for (int freq = 0; freq < sizeof(freqs)/sizeof(freqs[0]); freq++) 2584 { 2585 for (int chan = 0; chan < sizeof(_recChannelsPrioList)/sizeof(_recChannelsPrioList[0]); chan++) 2586 { 2587 Wfx.nChannels = _recChannelsPrioList[chan]; 2588 Wfx.nSamplesPerSec = freqs[freq]; 2589 Wfx.nBlockAlign = Wfx.nChannels * Wfx.wBitsPerSample / 8; 2590 Wfx.nAvgBytesPerSec = Wfx.nSamplesPerSec * Wfx.nBlockAlign; 2591 // If the method succeeds and the audio endpoint device supports the specified stream format, 2592 // it returns S_OK. If the method succeeds and provides a closest match to the specified format, 2593 // it returns S_FALSE. 2594 hr = _ptrClientIn->IsFormatSupported( 2595 AUDCLNT_SHAREMODE_SHARED, 2596 &Wfx, 2597 &pWfxClosestMatch); 2598 if (hr == S_OK) 2599 { 2600 break; 2601 } 2602 else 2603 { 2604 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nChannels=%d, nSamplesPerSec=%d is not supported", 2605 Wfx.nChannels, Wfx.nSamplesPerSec); 2606 } 2607 } 2608 if (hr == S_OK) 2609 break; 2610 } 2611 2612 if (hr == S_OK) 2613 { 2614 _recAudioFrameSize = Wfx.nBlockAlign; 2615 _recSampleRate = Wfx.nSamplesPerSec; 2616 _recBlockSize = Wfx.nSamplesPerSec/100; 2617 _recChannels = Wfx.nChannels; 2618 2619 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "VoE selected this capturing format:"); 2620 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wFormatTag : 0x%X (%u)", Wfx.wFormatTag, Wfx.wFormatTag); 2621 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nChannels : %d", Wfx.nChannels); 2622 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nSamplesPerSec : %d", Wfx.nSamplesPerSec); 2623 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nAvgBytesPerSec : %d", Wfx.nAvgBytesPerSec); 2624 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "nBlockAlign : %d", Wfx.nBlockAlign); 2625 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "wBitsPerSample : %d", Wfx.wBitsPerSample); 2626 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "cbSize : %d", Wfx.cbSize); 2627 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Additional settings:"); 2628 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_recAudioFrameSize: %d", _recAudioFrameSize); 2629 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_recBlockSize : %d", _recBlockSize); 2630 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_recChannels : %d", _recChannels); 2631 } 2632 2633 // Create a capturing stream. 2634 hr = _ptrClientIn->Initialize( 2635 AUDCLNT_SHAREMODE_SHARED, // share Audio Engine with other applications 2636 AUDCLNT_STREAMFLAGS_EVENTCALLBACK | // processing of the audio buffer by the client will be event driven 2637 AUDCLNT_STREAMFLAGS_NOPERSIST, // volume and mute settings for an audio session will not persist across system restarts 2638 0, // required for event-driven shared mode 2639 0, // periodicity 2640 &Wfx, // selected wave format 2641 NULL); // session GUID 2642 2643 2644 if (hr != S_OK) 2645 { 2646 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "IAudioClient::Initialize() failed:"); 2647 if (pWfxClosestMatch != NULL) 2648 { 2649 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "closest mix format: #channels=%d, samples/sec=%d, bits/sample=%d", 2650 pWfxClosestMatch->nChannels, pWfxClosestMatch->nSamplesPerSec, pWfxClosestMatch->wBitsPerSample); 2651 } 2652 else 2653 { 2654 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "no format suggested"); 2655 } 2656 } 2657 EXIT_ON_ERROR(hr); 2658 2659 if (_ptrAudioBuffer) 2660 { 2661 // Update the audio buffer with the selected parameters 2662 _ptrAudioBuffer->SetRecordingSampleRate(_recSampleRate); 2663 _ptrAudioBuffer->SetRecordingChannels((uint8_t)_recChannels); 2664 } 2665 else 2666 { 2667 // We can enter this state during CoreAudioIsSupported() when no AudioDeviceImplementation 2668 // has been created, hence the AudioDeviceBuffer does not exist. 2669 // It is OK to end up here since we don't initiate any media in CoreAudioIsSupported(). 2670 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceBuffer must be attached before streaming can start"); 2671 } 2672 2673 // Get the actual size of the shared (endpoint buffer). 2674 // Typical value is 960 audio frames <=> 20ms @ 48kHz sample rate. 2675 UINT bufferFrameCount(0); 2676 hr = _ptrClientIn->GetBufferSize( 2677 &bufferFrameCount); 2678 if (SUCCEEDED(hr)) 2679 { 2680 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "IAudioClient::GetBufferSize() => %u (<=> %u bytes)", 2681 bufferFrameCount, bufferFrameCount*_recAudioFrameSize); 2682 } 2683 2684 // Set the event handle that the system signals when an audio buffer is ready 2685 // to be processed by the client. 2686 hr = _ptrClientIn->SetEventHandle( 2687 _hCaptureSamplesReadyEvent); 2688 EXIT_ON_ERROR(hr); 2689 2690 // Get an IAudioCaptureClient interface. 2691 SAFE_RELEASE(_ptrCaptureClient); 2692 hr = _ptrClientIn->GetService( 2693 __uuidof(IAudioCaptureClient), 2694 (void**)&_ptrCaptureClient); 2695 EXIT_ON_ERROR(hr); 2696 2697 // Mark capture side as initialized 2698 _recIsInitialized = true; 2699 2700 CoTaskMemFree(pWfxIn); 2701 CoTaskMemFree(pWfxClosestMatch); 2702 2703 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "capture side is now initialized"); 2704 return 0; 2705 2706 Exit: 2707 _TraceCOMError(hr); 2708 CoTaskMemFree(pWfxIn); 2709 CoTaskMemFree(pWfxClosestMatch); 2710 SAFE_RELEASE(_ptrClientIn); 2711 SAFE_RELEASE(_ptrCaptureClient); 2712 return -1; 2713 } 2714 2715 // ---------------------------------------------------------------------------- 2716 // StartRecording 2717 // ---------------------------------------------------------------------------- 2718 2719 int32_t AudioDeviceWindowsCore::StartRecording() 2720 { 2721 2722 if (!_recIsInitialized) 2723 { 2724 return -1; 2725 } 2726 2727 if (_hRecThread != NULL) 2728 { 2729 return 0; 2730 } 2731 2732 if (_recording) 2733 { 2734 return 0; 2735 } 2736 2737 { 2738 CriticalSectionScoped critScoped(&_critSect); 2739 2740 // Create thread which will drive the capturing 2741 LPTHREAD_START_ROUTINE lpStartAddress = WSAPICaptureThread; 2742 if (_builtInAecEnabled) 2743 { 2744 // Redirect to the DMO polling method. 2745 lpStartAddress = WSAPICaptureThreadPollDMO; 2746 2747 if (!_playing) 2748 { 2749 // The DMO won't provide us captured output data unless we 2750 // give it render data to process. 2751 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2752 "Playout must be started before recording when using the " 2753 "built-in AEC"); 2754 return -1; 2755 } 2756 } 2757 2758 assert(_hRecThread == NULL); 2759 _hRecThread = CreateThread(NULL, 2760 0, 2761 lpStartAddress, 2762 this, 2763 0, 2764 NULL); 2765 if (_hRecThread == NULL) 2766 { 2767 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2768 "failed to create the recording thread"); 2769 return -1; 2770 } 2771 2772 // Set thread priority to highest possible 2773 SetThreadPriority(_hRecThread, THREAD_PRIORITY_TIME_CRITICAL); 2774 2775 assert(_hGetCaptureVolumeThread == NULL); 2776 _hGetCaptureVolumeThread = CreateThread(NULL, 2777 0, 2778 GetCaptureVolumeThread, 2779 this, 2780 0, 2781 NULL); 2782 if (_hGetCaptureVolumeThread == NULL) 2783 { 2784 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2785 " failed to create the volume getter thread"); 2786 return -1; 2787 } 2788 2789 assert(_hSetCaptureVolumeThread == NULL); 2790 _hSetCaptureVolumeThread = CreateThread(NULL, 2791 0, 2792 SetCaptureVolumeThread, 2793 this, 2794 0, 2795 NULL); 2796 if (_hSetCaptureVolumeThread == NULL) 2797 { 2798 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2799 " failed to create the volume setter thread"); 2800 return -1; 2801 } 2802 } // critScoped 2803 2804 DWORD ret = WaitForSingleObject(_hCaptureStartedEvent, 1000); 2805 if (ret != WAIT_OBJECT_0) 2806 { 2807 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2808 "capturing did not start up properly"); 2809 return -1; 2810 } 2811 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2812 "capture audio stream has now started..."); 2813 2814 _avgCPULoad = 0.0f; 2815 _playAcc = 0; 2816 _recording = true; 2817 2818 return 0; 2819 } 2820 2821 // ---------------------------------------------------------------------------- 2822 // StopRecording 2823 // ---------------------------------------------------------------------------- 2824 2825 int32_t AudioDeviceWindowsCore::StopRecording() 2826 { 2827 int32_t err = 0; 2828 2829 if (!_recIsInitialized) 2830 { 2831 return 0; 2832 } 2833 2834 _Lock(); 2835 2836 if (_hRecThread == NULL) 2837 { 2838 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2839 "no capturing stream is active => close down WASAPI only"); 2840 SAFE_RELEASE(_ptrClientIn); 2841 SAFE_RELEASE(_ptrCaptureClient); 2842 _recIsInitialized = false; 2843 _recording = false; 2844 _UnLock(); 2845 return 0; 2846 } 2847 2848 // Stop the driving thread... 2849 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2850 "closing down the webrtc_core_audio_capture_thread..."); 2851 // Manual-reset event; it will remain signalled to stop all capture threads. 2852 SetEvent(_hShutdownCaptureEvent); 2853 2854 _UnLock(); 2855 DWORD ret = WaitForSingleObject(_hRecThread, 2000); 2856 if (ret != WAIT_OBJECT_0) 2857 { 2858 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2859 "failed to close down webrtc_core_audio_capture_thread"); 2860 err = -1; 2861 } 2862 else 2863 { 2864 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2865 "webrtc_core_audio_capture_thread is now closed"); 2866 } 2867 2868 ret = WaitForSingleObject(_hGetCaptureVolumeThread, 2000); 2869 if (ret != WAIT_OBJECT_0) 2870 { 2871 // the thread did not stop as it should 2872 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2873 " failed to close down volume getter thread"); 2874 err = -1; 2875 } 2876 else 2877 { 2878 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2879 " volume getter thread is now closed"); 2880 } 2881 2882 ret = WaitForSingleObject(_hSetCaptureVolumeThread, 2000); 2883 if (ret != WAIT_OBJECT_0) 2884 { 2885 // the thread did not stop as it should 2886 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 2887 " failed to close down volume setter thread"); 2888 err = -1; 2889 } 2890 else 2891 { 2892 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 2893 " volume setter thread is now closed"); 2894 } 2895 _Lock(); 2896 2897 ResetEvent(_hShutdownCaptureEvent); // Must be manually reset. 2898 // Ensure that the thread has released these interfaces properly. 2899 assert(err == -1 || _ptrClientIn == NULL); 2900 assert(err == -1 || _ptrCaptureClient == NULL); 2901 2902 _recIsInitialized = false; 2903 _recording = false; 2904 2905 // These will create thread leaks in the result of an error, 2906 // but we can at least resume the call. 2907 CloseHandle(_hRecThread); 2908 _hRecThread = NULL; 2909 2910 CloseHandle(_hGetCaptureVolumeThread); 2911 _hGetCaptureVolumeThread = NULL; 2912 2913 CloseHandle(_hSetCaptureVolumeThread); 2914 _hSetCaptureVolumeThread = NULL; 2915 2916 if (_builtInAecEnabled) 2917 { 2918 assert(_dmo != NULL); 2919 // This is necessary. Otherwise the DMO can generate garbage render 2920 // audio even after rendering has stopped. 2921 HRESULT hr = _dmo->FreeStreamingResources(); 2922 if (FAILED(hr)) 2923 { 2924 _TraceCOMError(hr); 2925 err = -1; 2926 } 2927 } 2928 2929 // Reset the recording delay value. 2930 _sndCardRecDelay = 0; 2931 2932 _UnLock(); 2933 2934 return err; 2935 } 2936 2937 // ---------------------------------------------------------------------------- 2938 // RecordingIsInitialized 2939 // ---------------------------------------------------------------------------- 2940 2941 bool AudioDeviceWindowsCore::RecordingIsInitialized() const 2942 { 2943 return (_recIsInitialized); 2944 } 2945 2946 // ---------------------------------------------------------------------------- 2947 // Recording 2948 // ---------------------------------------------------------------------------- 2949 2950 bool AudioDeviceWindowsCore::Recording() const 2951 { 2952 return (_recording); 2953 } 2954 2955 // ---------------------------------------------------------------------------- 2956 // PlayoutIsInitialized 2957 // ---------------------------------------------------------------------------- 2958 2959 bool AudioDeviceWindowsCore::PlayoutIsInitialized() const 2960 { 2961 2962 return (_playIsInitialized); 2963 } 2964 2965 // ---------------------------------------------------------------------------- 2966 // StartPlayout 2967 // ---------------------------------------------------------------------------- 2968 2969 int32_t AudioDeviceWindowsCore::StartPlayout() 2970 { 2971 2972 if (!_playIsInitialized) 2973 { 2974 return -1; 2975 } 2976 2977 if (_hPlayThread != NULL) 2978 { 2979 return 0; 2980 } 2981 2982 if (_playing) 2983 { 2984 return 0; 2985 } 2986 2987 { 2988 CriticalSectionScoped critScoped(&_critSect); 2989 2990 // Create thread which will drive the rendering. 2991 assert(_hPlayThread == NULL); 2992 _hPlayThread = CreateThread( 2993 NULL, 2994 0, 2995 WSAPIRenderThread, 2996 this, 2997 0, 2998 NULL); 2999 if (_hPlayThread == NULL) 3000 { 3001 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 3002 "failed to create the playout thread"); 3003 return -1; 3004 } 3005 3006 // Set thread priority to highest possible. 3007 SetThreadPriority(_hPlayThread, THREAD_PRIORITY_TIME_CRITICAL); 3008 } // critScoped 3009 3010 DWORD ret = WaitForSingleObject(_hRenderStartedEvent, 1000); 3011 if (ret != WAIT_OBJECT_0) 3012 { 3013 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3014 "rendering did not start up properly"); 3015 return -1; 3016 } 3017 3018 _playing = true; 3019 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3020 "rendering audio stream has now started..."); 3021 3022 return 0; 3023 } 3024 3025 // ---------------------------------------------------------------------------- 3026 // StopPlayout 3027 // ---------------------------------------------------------------------------- 3028 3029 int32_t AudioDeviceWindowsCore::StopPlayout() 3030 { 3031 3032 if (!_playIsInitialized) 3033 { 3034 return 0; 3035 } 3036 3037 { 3038 CriticalSectionScoped critScoped(&_critSect) ; 3039 3040 if (_hPlayThread == NULL) 3041 { 3042 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3043 "no rendering stream is active => close down WASAPI only"); 3044 SAFE_RELEASE(_ptrClientOut); 3045 SAFE_RELEASE(_ptrRenderClient); 3046 _playIsInitialized = false; 3047 _playing = false; 3048 return 0; 3049 } 3050 3051 // stop the driving thread... 3052 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3053 "closing down the webrtc_core_audio_render_thread..."); 3054 SetEvent(_hShutdownRenderEvent); 3055 } // critScoped 3056 3057 DWORD ret = WaitForSingleObject(_hPlayThread, 2000); 3058 if (ret != WAIT_OBJECT_0) 3059 { 3060 // the thread did not stop as it should 3061 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 3062 "failed to close down webrtc_core_audio_render_thread"); 3063 CloseHandle(_hPlayThread); 3064 _hPlayThread = NULL; 3065 _playIsInitialized = false; 3066 _playing = false; 3067 return -1; 3068 } 3069 3070 { 3071 CriticalSectionScoped critScoped(&_critSect); 3072 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3073 "webrtc_core_audio_render_thread is now closed"); 3074 3075 // to reset this event manually at each time we finish with it, 3076 // in case that the render thread has exited before StopPlayout(), 3077 // this event might be caught by the new render thread within same VoE instance. 3078 ResetEvent(_hShutdownRenderEvent); 3079 3080 SAFE_RELEASE(_ptrClientOut); 3081 SAFE_RELEASE(_ptrRenderClient); 3082 3083 _playIsInitialized = false; 3084 _playing = false; 3085 3086 CloseHandle(_hPlayThread); 3087 _hPlayThread = NULL; 3088 3089 if (_builtInAecEnabled && _recording) 3090 { 3091 // The DMO won't provide us captured output data unless we 3092 // give it render data to process. 3093 // 3094 // We still permit the playout to shutdown, and trace a warning. 3095 // Otherwise, VoE can get into a state which will never permit 3096 // playout to stop properly. 3097 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3098 "Recording should be stopped before playout when using the " 3099 "built-in AEC"); 3100 } 3101 3102 // Reset the playout delay value. 3103 _sndCardPlayDelay = 0; 3104 } // critScoped 3105 3106 return 0; 3107 } 3108 3109 // ---------------------------------------------------------------------------- 3110 // PlayoutDelay 3111 // ---------------------------------------------------------------------------- 3112 3113 int32_t AudioDeviceWindowsCore::PlayoutDelay(uint16_t& delayMS) const 3114 { 3115 CriticalSectionScoped critScoped(&_critSect); 3116 delayMS = static_cast<uint16_t>(_sndCardPlayDelay); 3117 return 0; 3118 } 3119 3120 // ---------------------------------------------------------------------------- 3121 // RecordingDelay 3122 // ---------------------------------------------------------------------------- 3123 3124 int32_t AudioDeviceWindowsCore::RecordingDelay(uint16_t& delayMS) const 3125 { 3126 CriticalSectionScoped critScoped(&_critSect); 3127 delayMS = static_cast<uint16_t>(_sndCardRecDelay); 3128 return 0; 3129 } 3130 3131 // ---------------------------------------------------------------------------- 3132 // Playing 3133 // ---------------------------------------------------------------------------- 3134 3135 bool AudioDeviceWindowsCore::Playing() const 3136 { 3137 return (_playing); 3138 } 3139 // ---------------------------------------------------------------------------- 3140 // SetPlayoutBuffer 3141 // ---------------------------------------------------------------------------- 3142 3143 int32_t AudioDeviceWindowsCore::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS) 3144 { 3145 3146 CriticalSectionScoped lock(&_critSect); 3147 3148 _playBufType = type; 3149 3150 if (type == AudioDeviceModule::kFixedBufferSize) 3151 { 3152 _playBufDelayFixed = sizeMS; 3153 } 3154 3155 return 0; 3156 } 3157 3158 // ---------------------------------------------------------------------------- 3159 // PlayoutBuffer 3160 // ---------------------------------------------------------------------------- 3161 3162 int32_t AudioDeviceWindowsCore::PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const 3163 { 3164 CriticalSectionScoped lock(&_critSect); 3165 type = _playBufType; 3166 3167 if (type == AudioDeviceModule::kFixedBufferSize) 3168 { 3169 sizeMS = _playBufDelayFixed; 3170 } 3171 else 3172 { 3173 // Use same value as for PlayoutDelay 3174 sizeMS = static_cast<uint16_t>(_sndCardPlayDelay); 3175 } 3176 3177 return 0; 3178 } 3179 3180 // ---------------------------------------------------------------------------- 3181 // CPULoad 3182 // ---------------------------------------------------------------------------- 3183 3184 int32_t AudioDeviceWindowsCore::CPULoad(uint16_t& load) const 3185 { 3186 3187 load = static_cast<uint16_t> (100*_avgCPULoad); 3188 3189 return 0; 3190 } 3191 3192 // ---------------------------------------------------------------------------- 3193 // PlayoutWarning 3194 // ---------------------------------------------------------------------------- 3195 3196 bool AudioDeviceWindowsCore::PlayoutWarning() const 3197 { 3198 return ( _playWarning > 0); 3199 } 3200 3201 // ---------------------------------------------------------------------------- 3202 // PlayoutError 3203 // ---------------------------------------------------------------------------- 3204 3205 bool AudioDeviceWindowsCore::PlayoutError() const 3206 { 3207 return ( _playError > 0); 3208 } 3209 3210 // ---------------------------------------------------------------------------- 3211 // RecordingWarning 3212 // ---------------------------------------------------------------------------- 3213 3214 bool AudioDeviceWindowsCore::RecordingWarning() const 3215 { 3216 return ( _recWarning > 0); 3217 } 3218 3219 // ---------------------------------------------------------------------------- 3220 // RecordingError 3221 // ---------------------------------------------------------------------------- 3222 3223 bool AudioDeviceWindowsCore::RecordingError() const 3224 { 3225 return ( _recError > 0); 3226 } 3227 3228 // ---------------------------------------------------------------------------- 3229 // ClearPlayoutWarning 3230 // ---------------------------------------------------------------------------- 3231 3232 void AudioDeviceWindowsCore::ClearPlayoutWarning() 3233 { 3234 _playWarning = 0; 3235 } 3236 3237 // ---------------------------------------------------------------------------- 3238 // ClearPlayoutError 3239 // ---------------------------------------------------------------------------- 3240 3241 void AudioDeviceWindowsCore::ClearPlayoutError() 3242 { 3243 _playError = 0; 3244 } 3245 3246 // ---------------------------------------------------------------------------- 3247 // ClearRecordingWarning 3248 // ---------------------------------------------------------------------------- 3249 3250 void AudioDeviceWindowsCore::ClearRecordingWarning() 3251 { 3252 _recWarning = 0; 3253 } 3254 3255 // ---------------------------------------------------------------------------- 3256 // ClearRecordingError 3257 // ---------------------------------------------------------------------------- 3258 3259 void AudioDeviceWindowsCore::ClearRecordingError() 3260 { 3261 _recError = 0; 3262 } 3263 3264 // ============================================================================ 3265 // Private Methods 3266 // ============================================================================ 3267 3268 // ---------------------------------------------------------------------------- 3269 // [static] WSAPIRenderThread 3270 // ---------------------------------------------------------------------------- 3271 3272 DWORD WINAPI AudioDeviceWindowsCore::WSAPIRenderThread(LPVOID context) 3273 { 3274 return reinterpret_cast<AudioDeviceWindowsCore*>(context)-> 3275 DoRenderThread(); 3276 } 3277 3278 // ---------------------------------------------------------------------------- 3279 // [static] WSAPICaptureThread 3280 // ---------------------------------------------------------------------------- 3281 3282 DWORD WINAPI AudioDeviceWindowsCore::WSAPICaptureThread(LPVOID context) 3283 { 3284 return reinterpret_cast<AudioDeviceWindowsCore*>(context)-> 3285 DoCaptureThread(); 3286 } 3287 3288 DWORD WINAPI AudioDeviceWindowsCore::WSAPICaptureThreadPollDMO(LPVOID context) 3289 { 3290 return reinterpret_cast<AudioDeviceWindowsCore*>(context)-> 3291 DoCaptureThreadPollDMO(); 3292 } 3293 3294 DWORD WINAPI AudioDeviceWindowsCore::GetCaptureVolumeThread(LPVOID context) 3295 { 3296 return reinterpret_cast<AudioDeviceWindowsCore*>(context)-> 3297 DoGetCaptureVolumeThread(); 3298 } 3299 3300 DWORD WINAPI AudioDeviceWindowsCore::SetCaptureVolumeThread(LPVOID context) 3301 { 3302 return reinterpret_cast<AudioDeviceWindowsCore*>(context)-> 3303 DoSetCaptureVolumeThread(); 3304 } 3305 3306 DWORD AudioDeviceWindowsCore::DoGetCaptureVolumeThread() 3307 { 3308 HANDLE waitObject = _hShutdownCaptureEvent; 3309 3310 while (1) 3311 { 3312 if (AGC()) 3313 { 3314 uint32_t currentMicLevel = 0; 3315 if (MicrophoneVolume(currentMicLevel) == 0) 3316 { 3317 // This doesn't set the system volume, just stores it. 3318 _Lock(); 3319 if (_ptrAudioBuffer) 3320 { 3321 _ptrAudioBuffer->SetCurrentMicLevel(currentMicLevel); 3322 } 3323 _UnLock(); 3324 } 3325 } 3326 3327 DWORD waitResult = WaitForSingleObject(waitObject, 3328 GET_MIC_VOLUME_INTERVAL_MS); 3329 switch (waitResult) 3330 { 3331 case WAIT_OBJECT_0: // _hShutdownCaptureEvent 3332 return 0; 3333 case WAIT_TIMEOUT: // timeout notification 3334 break; 3335 default: // unexpected error 3336 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3337 " unknown wait termination on get volume thread"); 3338 return -1; 3339 } 3340 } 3341 } 3342 3343 DWORD AudioDeviceWindowsCore::DoSetCaptureVolumeThread() 3344 { 3345 HANDLE waitArray[2] = {_hShutdownCaptureEvent, _hSetCaptureVolumeEvent}; 3346 3347 while (1) 3348 { 3349 DWORD waitResult = WaitForMultipleObjects(2, waitArray, FALSE, INFINITE); 3350 switch (waitResult) 3351 { 3352 case WAIT_OBJECT_0: // _hShutdownCaptureEvent 3353 return 0; 3354 case WAIT_OBJECT_0 + 1: // _hSetCaptureVolumeEvent 3355 break; 3356 default: // unexpected error 3357 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3358 " unknown wait termination on set volume thread"); 3359 return -1; 3360 } 3361 3362 _Lock(); 3363 uint32_t newMicLevel = _newMicLevel; 3364 _UnLock(); 3365 3366 if (SetMicrophoneVolume(newMicLevel) == -1) 3367 { 3368 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3369 " the required modification of the microphone volume failed"); 3370 } 3371 } 3372 } 3373 3374 // ---------------------------------------------------------------------------- 3375 // DoRenderThread 3376 // ---------------------------------------------------------------------------- 3377 3378 DWORD AudioDeviceWindowsCore::DoRenderThread() 3379 { 3380 3381 bool keepPlaying = true; 3382 HANDLE waitArray[2] = {_hShutdownRenderEvent, _hRenderSamplesReadyEvent}; 3383 HRESULT hr = S_OK; 3384 HANDLE hMmTask = NULL; 3385 3386 LARGE_INTEGER t1; 3387 LARGE_INTEGER t2; 3388 int32_t time(0); 3389 3390 // Initialize COM as MTA in this thread. 3391 ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA); 3392 if (!comInit.succeeded()) { 3393 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 3394 "failed to initialize COM in render thread"); 3395 return -1; 3396 } 3397 3398 _SetThreadName(-1, "webrtc_core_audio_render_thread"); 3399 3400 // Use Multimedia Class Scheduler Service (MMCSS) to boost the thread priority. 3401 // 3402 if (_winSupportAvrt) 3403 { 3404 DWORD taskIndex(0); 3405 hMmTask = _PAvSetMmThreadCharacteristicsA("Pro Audio", &taskIndex); 3406 if (hMmTask) 3407 { 3408 if (FALSE == _PAvSetMmThreadPriority(hMmTask, AVRT_PRIORITY_CRITICAL)) 3409 { 3410 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "failed to boost play-thread using MMCSS"); 3411 } 3412 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "render thread is now registered with MMCSS (taskIndex=%d)", taskIndex); 3413 } 3414 else 3415 { 3416 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "failed to enable MMCSS on render thread (err=%d)", GetLastError()); 3417 _TraceCOMError(GetLastError()); 3418 } 3419 } 3420 3421 _Lock(); 3422 3423 IAudioClock* clock = NULL; 3424 3425 // Get size of rendering buffer (length is expressed as the number of audio frames the buffer can hold). 3426 // This value is fixed during the rendering session. 3427 // 3428 UINT32 bufferLength = 0; 3429 hr = _ptrClientOut->GetBufferSize(&bufferLength); 3430 EXIT_ON_ERROR(hr); 3431 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[REND] size of buffer : %u", bufferLength); 3432 3433 // Get maximum latency for the current stream (will not change for the lifetime of the IAudioClient object). 3434 // 3435 REFERENCE_TIME latency; 3436 _ptrClientOut->GetStreamLatency(&latency); 3437 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[REND] max stream latency : %u (%3.2f ms)", 3438 (DWORD)latency, (double)(latency/10000.0)); 3439 3440 // Get the length of the periodic interval separating successive processing passes by 3441 // the audio engine on the data in the endpoint buffer. 3442 // 3443 // The period between processing passes by the audio engine is fixed for a particular 3444 // audio endpoint device and represents the smallest processing quantum for the audio engine. 3445 // This period plus the stream latency between the buffer and endpoint device represents 3446 // the minimum possible latency that an audio application can achieve. 3447 // Typical value: 100000 <=> 0.01 sec = 10ms. 3448 // 3449 REFERENCE_TIME devPeriod = 0; 3450 REFERENCE_TIME devPeriodMin = 0; 3451 _ptrClientOut->GetDevicePeriod(&devPeriod, &devPeriodMin); 3452 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[REND] device period : %u (%3.2f ms)", 3453 (DWORD)devPeriod, (double)(devPeriod/10000.0)); 3454 3455 // Derive initial rendering delay. 3456 // Example: 10*(960/480) + 15 = 20 + 15 = 35ms 3457 // 3458 int playout_delay = 10 * (bufferLength / _playBlockSize) + 3459 (int)((latency + devPeriod) / 10000); 3460 _sndCardPlayDelay = playout_delay; 3461 _writtenSamples = 0; 3462 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3463 "[REND] initial delay : %u", playout_delay); 3464 3465 double endpointBufferSizeMS = 10.0 * ((double)bufferLength / (double)_devicePlayBlockSize); 3466 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[REND] endpointBufferSizeMS : %3.2f", endpointBufferSizeMS); 3467 3468 // Before starting the stream, fill the rendering buffer with silence. 3469 // 3470 BYTE *pData = NULL; 3471 hr = _ptrRenderClient->GetBuffer(bufferLength, &pData); 3472 EXIT_ON_ERROR(hr); 3473 3474 hr = _ptrRenderClient->ReleaseBuffer(bufferLength, AUDCLNT_BUFFERFLAGS_SILENT); 3475 EXIT_ON_ERROR(hr); 3476 3477 _writtenSamples += bufferLength; 3478 3479 hr = _ptrClientOut->GetService(__uuidof(IAudioClock), (void**)&clock); 3480 if (FAILED(hr)) { 3481 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3482 "failed to get IAudioClock interface from the IAudioClient"); 3483 } 3484 3485 // Start up the rendering audio stream. 3486 hr = _ptrClientOut->Start(); 3487 EXIT_ON_ERROR(hr); 3488 3489 _UnLock(); 3490 3491 // Set event which will ensure that the calling thread modifies the playing state to true. 3492 // 3493 SetEvent(_hRenderStartedEvent); 3494 3495 // >> ------------------ THREAD LOOP ------------------ 3496 3497 while (keepPlaying) 3498 { 3499 // Wait for a render notification event or a shutdown event 3500 DWORD waitResult = WaitForMultipleObjects(2, waitArray, FALSE, 500); 3501 switch (waitResult) 3502 { 3503 case WAIT_OBJECT_0 + 0: // _hShutdownRenderEvent 3504 keepPlaying = false; 3505 break; 3506 case WAIT_OBJECT_0 + 1: // _hRenderSamplesReadyEvent 3507 break; 3508 case WAIT_TIMEOUT: // timeout notification 3509 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "render event timed out after 0.5 seconds"); 3510 goto Exit; 3511 default: // unexpected error 3512 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "unknown wait termination on render side"); 3513 goto Exit; 3514 } 3515 3516 while (keepPlaying) 3517 { 3518 _Lock(); 3519 3520 // Sanity check to ensure that essential states are not modified 3521 // during the unlocked period. 3522 if (_ptrRenderClient == NULL || _ptrClientOut == NULL) 3523 { 3524 _UnLock(); 3525 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 3526 "output state has been modified during unlocked period"); 3527 goto Exit; 3528 } 3529 3530 // Get the number of frames of padding (queued up to play) in the endpoint buffer. 3531 UINT32 padding = 0; 3532 hr = _ptrClientOut->GetCurrentPadding(&padding); 3533 EXIT_ON_ERROR(hr); 3534 3535 // Derive the amount of available space in the output buffer 3536 uint32_t framesAvailable = bufferLength - padding; 3537 // WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "#avaliable audio frames = %u", framesAvailable); 3538 3539 // Do we have 10 ms available in the render buffer? 3540 if (framesAvailable < _playBlockSize) 3541 { 3542 // Not enough space in render buffer to store next render packet. 3543 _UnLock(); 3544 break; 3545 } 3546 3547 // Write n*10ms buffers to the render buffer 3548 const uint32_t n10msBuffers = (framesAvailable / _playBlockSize); 3549 for (uint32_t n = 0; n < n10msBuffers; n++) 3550 { 3551 // Get pointer (i.e., grab the buffer) to next space in the shared render buffer. 3552 hr = _ptrRenderClient->GetBuffer(_playBlockSize, &pData); 3553 EXIT_ON_ERROR(hr); 3554 3555 QueryPerformanceCounter(&t1); // measure time: START 3556 3557 if (_ptrAudioBuffer) 3558 { 3559 // Request data to be played out (#bytes = _playBlockSize*_audioFrameSize) 3560 _UnLock(); 3561 int32_t nSamples = 3562 _ptrAudioBuffer->RequestPlayoutData(_playBlockSize); 3563 _Lock(); 3564 3565 if (nSamples == -1) 3566 { 3567 _UnLock(); 3568 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 3569 "failed to read data from render client"); 3570 goto Exit; 3571 } 3572 3573 // Sanity check to ensure that essential states are not modified during the unlocked period 3574 if (_ptrRenderClient == NULL || _ptrClientOut == NULL) 3575 { 3576 _UnLock(); 3577 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "output state has been modified during unlocked period"); 3578 goto Exit; 3579 } 3580 if (nSamples != static_cast<int32_t>(_playBlockSize)) 3581 { 3582 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "nSamples(%d) != _playBlockSize(%d)", nSamples, _playBlockSize); 3583 } 3584 3585 // Get the actual (stored) data 3586 nSamples = _ptrAudioBuffer->GetPlayoutData((int8_t*)pData); 3587 } 3588 3589 QueryPerformanceCounter(&t2); // measure time: STOP 3590 time = (int)(t2.QuadPart-t1.QuadPart); 3591 _playAcc += time; 3592 3593 DWORD dwFlags(0); 3594 hr = _ptrRenderClient->ReleaseBuffer(_playBlockSize, dwFlags); 3595 // See http://msdn.microsoft.com/en-us/library/dd316605(VS.85).aspx 3596 // for more details regarding AUDCLNT_E_DEVICE_INVALIDATED. 3597 EXIT_ON_ERROR(hr); 3598 3599 _writtenSamples += _playBlockSize; 3600 } 3601 3602 // Check the current delay on the playout side. 3603 if (clock) { 3604 UINT64 pos = 0; 3605 UINT64 freq = 1; 3606 clock->GetPosition(&pos, NULL); 3607 clock->GetFrequency(&freq); 3608 playout_delay = ROUND((double(_writtenSamples) / 3609 _devicePlaySampleRate - double(pos) / freq) * 1000.0); 3610 _sndCardPlayDelay = playout_delay; 3611 } 3612 3613 _UnLock(); 3614 } 3615 } 3616 3617 // ------------------ THREAD LOOP ------------------ << 3618 3619 SleepMs(static_cast<DWORD>(endpointBufferSizeMS+0.5)); 3620 hr = _ptrClientOut->Stop(); 3621 3622 Exit: 3623 SAFE_RELEASE(clock); 3624 3625 if (FAILED(hr)) 3626 { 3627 _ptrClientOut->Stop(); 3628 _UnLock(); 3629 _TraceCOMError(hr); 3630 } 3631 3632 if (_winSupportAvrt) 3633 { 3634 if (NULL != hMmTask) 3635 { 3636 _PAvRevertMmThreadCharacteristics(hMmTask); 3637 } 3638 } 3639 3640 _Lock(); 3641 3642 if (keepPlaying) 3643 { 3644 if (_ptrClientOut != NULL) 3645 { 3646 hr = _ptrClientOut->Stop(); 3647 if (FAILED(hr)) 3648 { 3649 _TraceCOMError(hr); 3650 } 3651 hr = _ptrClientOut->Reset(); 3652 if (FAILED(hr)) 3653 { 3654 _TraceCOMError(hr); 3655 } 3656 } 3657 // Trigger callback from module process thread 3658 _playError = 1; 3659 WEBRTC_TRACE(kTraceError, kTraceUtility, _id, "kPlayoutError message posted: rendering thread has ended pre-maturely"); 3660 } 3661 else 3662 { 3663 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_Rendering thread is now terminated properly"); 3664 } 3665 3666 _UnLock(); 3667 3668 return (DWORD)hr; 3669 } 3670 3671 DWORD AudioDeviceWindowsCore::InitCaptureThreadPriority() 3672 { 3673 _hMmTask = NULL; 3674 3675 _SetThreadName(-1, "webrtc_core_audio_capture_thread"); 3676 3677 // Use Multimedia Class Scheduler Service (MMCSS) to boost the thread 3678 // priority. 3679 if (_winSupportAvrt) 3680 { 3681 DWORD taskIndex(0); 3682 _hMmTask = _PAvSetMmThreadCharacteristicsA("Pro Audio", &taskIndex); 3683 if (_hMmTask) 3684 { 3685 if (!_PAvSetMmThreadPriority(_hMmTask, AVRT_PRIORITY_CRITICAL)) 3686 { 3687 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3688 "failed to boost rec-thread using MMCSS"); 3689 } 3690 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3691 "capture thread is now registered with MMCSS (taskIndex=%d)", 3692 taskIndex); 3693 } 3694 else 3695 { 3696 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3697 "failed to enable MMCSS on capture thread (err=%d)", 3698 GetLastError()); 3699 _TraceCOMError(GetLastError()); 3700 } 3701 } 3702 3703 return S_OK; 3704 } 3705 3706 void AudioDeviceWindowsCore::RevertCaptureThreadPriority() 3707 { 3708 if (_winSupportAvrt) 3709 { 3710 if (NULL != _hMmTask) 3711 { 3712 _PAvRevertMmThreadCharacteristics(_hMmTask); 3713 } 3714 } 3715 3716 _hMmTask = NULL; 3717 } 3718 3719 DWORD AudioDeviceWindowsCore::DoCaptureThreadPollDMO() 3720 { 3721 assert(_mediaBuffer != NULL); 3722 bool keepRecording = true; 3723 3724 // Initialize COM as MTA in this thread. 3725 ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA); 3726 if (!comInit.succeeded()) { 3727 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 3728 "failed to initialize COM in polling DMO thread"); 3729 return -1; 3730 } 3731 3732 HRESULT hr = InitCaptureThreadPriority(); 3733 if (FAILED(hr)) 3734 { 3735 return hr; 3736 } 3737 3738 // Set event which will ensure that the calling thread modifies the 3739 // recording state to true. 3740 SetEvent(_hCaptureStartedEvent); 3741 3742 // >> ---------------------------- THREAD LOOP ---------------------------- 3743 while (keepRecording) 3744 { 3745 // Poll the DMO every 5 ms. 3746 // (The same interval used in the Wave implementation.) 3747 DWORD waitResult = WaitForSingleObject(_hShutdownCaptureEvent, 5); 3748 switch (waitResult) 3749 { 3750 case WAIT_OBJECT_0: // _hShutdownCaptureEvent 3751 keepRecording = false; 3752 break; 3753 case WAIT_TIMEOUT: // timeout notification 3754 break; 3755 default: // unexpected error 3756 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, 3757 "Unknown wait termination on capture side"); 3758 hr = -1; // To signal an error callback. 3759 keepRecording = false; 3760 break; 3761 } 3762 3763 while (keepRecording) 3764 { 3765 CriticalSectionScoped critScoped(&_critSect); 3766 3767 DWORD dwStatus = 0; 3768 { 3769 DMO_OUTPUT_DATA_BUFFER dmoBuffer = {0}; 3770 dmoBuffer.pBuffer = _mediaBuffer; 3771 dmoBuffer.pBuffer->AddRef(); 3772 3773 // Poll the DMO for AEC processed capture data. The DMO will 3774 // copy available data to |dmoBuffer|, and should only return 3775 // 10 ms frames. The value of |dwStatus| should be ignored. 3776 hr = _dmo->ProcessOutput(0, 1, &dmoBuffer, &dwStatus); 3777 SAFE_RELEASE(dmoBuffer.pBuffer); 3778 dwStatus = dmoBuffer.dwStatus; 3779 } 3780 if (FAILED(hr)) 3781 { 3782 _TraceCOMError(hr); 3783 keepRecording = false; 3784 assert(false); 3785 break; 3786 } 3787 3788 ULONG bytesProduced = 0; 3789 BYTE* data; 3790 // Get a pointer to the data buffer. This should be valid until 3791 // the next call to ProcessOutput. 3792 hr = _mediaBuffer->GetBufferAndLength(&data, &bytesProduced); 3793 if (FAILED(hr)) 3794 { 3795 _TraceCOMError(hr); 3796 keepRecording = false; 3797 assert(false); 3798 break; 3799 } 3800 3801 // TODO(andrew): handle AGC. 3802 3803 if (bytesProduced > 0) 3804 { 3805 const int kSamplesProduced = bytesProduced / _recAudioFrameSize; 3806 // TODO(andrew): verify that this is always satisfied. It might 3807 // be that ProcessOutput will try to return more than 10 ms if 3808 // we fail to call it frequently enough. 3809 assert(kSamplesProduced == static_cast<int>(_recBlockSize)); 3810 assert(sizeof(BYTE) == sizeof(int8_t)); 3811 _ptrAudioBuffer->SetRecordedBuffer( 3812 reinterpret_cast<int8_t*>(data), 3813 kSamplesProduced); 3814 _ptrAudioBuffer->SetVQEData(0, 0, 0); 3815 3816 _UnLock(); // Release lock while making the callback. 3817 _ptrAudioBuffer->DeliverRecordedData(); 3818 _Lock(); 3819 } 3820 3821 // Reset length to indicate buffer availability. 3822 hr = _mediaBuffer->SetLength(0); 3823 if (FAILED(hr)) 3824 { 3825 _TraceCOMError(hr); 3826 keepRecording = false; 3827 assert(false); 3828 break; 3829 } 3830 3831 if (!(dwStatus & DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE)) 3832 { 3833 // The DMO cannot currently produce more data. This is the 3834 // normal case; otherwise it means the DMO had more than 10 ms 3835 // of data available and ProcessOutput should be called again. 3836 break; 3837 } 3838 } 3839 } 3840 // ---------------------------- THREAD LOOP ---------------------------- << 3841 3842 RevertCaptureThreadPriority(); 3843 3844 if (FAILED(hr)) 3845 { 3846 // Trigger callback from module process thread 3847 _recError = 1; 3848 WEBRTC_TRACE(kTraceError, kTraceUtility, _id, 3849 "kRecordingError message posted: capturing thread has ended " 3850 "prematurely"); 3851 } 3852 else 3853 { 3854 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 3855 "Capturing thread is now terminated properly"); 3856 } 3857 3858 return hr; 3859 } 3860 3861 3862 // ---------------------------------------------------------------------------- 3863 // DoCaptureThread 3864 // ---------------------------------------------------------------------------- 3865 3866 DWORD AudioDeviceWindowsCore::DoCaptureThread() 3867 { 3868 3869 bool keepRecording = true; 3870 HANDLE waitArray[2] = {_hShutdownCaptureEvent, _hCaptureSamplesReadyEvent}; 3871 HRESULT hr = S_OK; 3872 3873 LARGE_INTEGER t1; 3874 LARGE_INTEGER t2; 3875 int32_t time(0); 3876 3877 BYTE* syncBuffer = NULL; 3878 UINT32 syncBufIndex = 0; 3879 3880 _readSamples = 0; 3881 3882 // Initialize COM as MTA in this thread. 3883 ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA); 3884 if (!comInit.succeeded()) { 3885 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 3886 "failed to initialize COM in capture thread"); 3887 return -1; 3888 } 3889 3890 hr = InitCaptureThreadPriority(); 3891 if (FAILED(hr)) 3892 { 3893 return hr; 3894 } 3895 3896 _Lock(); 3897 3898 // Get size of capturing buffer (length is expressed as the number of audio frames the buffer can hold). 3899 // This value is fixed during the capturing session. 3900 // 3901 UINT32 bufferLength = 0; 3902 hr = _ptrClientIn->GetBufferSize(&bufferLength); 3903 EXIT_ON_ERROR(hr); 3904 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[CAPT] size of buffer : %u", bufferLength); 3905 3906 // Allocate memory for sync buffer. 3907 // It is used for compensation between native 44.1 and internal 44.0 and 3908 // for cases when the capture buffer is larger than 10ms. 3909 // 3910 const UINT32 syncBufferSize = 2*(bufferLength * _recAudioFrameSize); 3911 syncBuffer = new BYTE[syncBufferSize]; 3912 if (syncBuffer == NULL) 3913 { 3914 return E_POINTER; 3915 } 3916 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[CAPT] size of sync buffer : %u [bytes]", syncBufferSize); 3917 3918 // Get maximum latency for the current stream (will not change for the lifetime of the IAudioClient object). 3919 // 3920 REFERENCE_TIME latency; 3921 _ptrClientIn->GetStreamLatency(&latency); 3922 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[CAPT] max stream latency : %u (%3.2f ms)", 3923 (DWORD)latency, (double)(latency / 10000.0)); 3924 3925 // Get the length of the periodic interval separating successive processing passes by 3926 // the audio engine on the data in the endpoint buffer. 3927 // 3928 REFERENCE_TIME devPeriod = 0; 3929 REFERENCE_TIME devPeriodMin = 0; 3930 _ptrClientIn->GetDevicePeriod(&devPeriod, &devPeriodMin); 3931 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[CAPT] device period : %u (%3.2f ms)", 3932 (DWORD)devPeriod, (double)(devPeriod / 10000.0)); 3933 3934 double extraDelayMS = (double)((latency + devPeriod) / 10000.0); 3935 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[CAPT] extraDelayMS : %3.2f", extraDelayMS); 3936 3937 double endpointBufferSizeMS = 10.0 * ((double)bufferLength / (double)_recBlockSize); 3938 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "[CAPT] endpointBufferSizeMS : %3.2f", endpointBufferSizeMS); 3939 3940 // Start up the capturing stream. 3941 // 3942 hr = _ptrClientIn->Start(); 3943 EXIT_ON_ERROR(hr); 3944 3945 _UnLock(); 3946 3947 // Set event which will ensure that the calling thread modifies the recording state to true. 3948 // 3949 SetEvent(_hCaptureStartedEvent); 3950 3951 // >> ---------------------------- THREAD LOOP ---------------------------- 3952 3953 while (keepRecording) 3954 { 3955 // Wait for a capture notification event or a shutdown event 3956 DWORD waitResult = WaitForMultipleObjects(2, waitArray, FALSE, 500); 3957 switch (waitResult) 3958 { 3959 case WAIT_OBJECT_0 + 0: // _hShutdownCaptureEvent 3960 keepRecording = false; 3961 break; 3962 case WAIT_OBJECT_0 + 1: // _hCaptureSamplesReadyEvent 3963 break; 3964 case WAIT_TIMEOUT: // timeout notification 3965 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "capture event timed out after 0.5 seconds"); 3966 goto Exit; 3967 default: // unexpected error 3968 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "unknown wait termination on capture side"); 3969 goto Exit; 3970 } 3971 3972 while (keepRecording) 3973 { 3974 BYTE *pData = 0; 3975 UINT32 framesAvailable = 0; 3976 DWORD flags = 0; 3977 UINT64 recTime = 0; 3978 UINT64 recPos = 0; 3979 3980 _Lock(); 3981 3982 // Sanity check to ensure that essential states are not modified 3983 // during the unlocked period. 3984 if (_ptrCaptureClient == NULL || _ptrClientIn == NULL) 3985 { 3986 _UnLock(); 3987 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, 3988 "input state has been modified during unlocked period"); 3989 goto Exit; 3990 } 3991 3992 // Find out how much capture data is available 3993 // 3994 hr = _ptrCaptureClient->GetBuffer(&pData, // packet which is ready to be read by used 3995 &framesAvailable, // #frames in the captured packet (can be zero) 3996 &flags, // support flags (check) 3997 &recPos, // device position of first audio frame in data packet 3998 &recTime); // value of performance counter at the time of recording the first audio frame 3999 4000 if (SUCCEEDED(hr)) 4001 { 4002 if (AUDCLNT_S_BUFFER_EMPTY == hr) 4003 { 4004 // Buffer was empty => start waiting for a new capture notification event 4005 _UnLock(); 4006 break; 4007 } 4008 4009 if (flags & AUDCLNT_BUFFERFLAGS_SILENT) 4010 { 4011 // Treat all of the data in the packet as silence and ignore the actual data values. 4012 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "AUDCLNT_BUFFERFLAGS_SILENT"); 4013 pData = NULL; 4014 } 4015 4016 assert(framesAvailable != 0); 4017 4018 if (pData) 4019 { 4020 CopyMemory(&syncBuffer[syncBufIndex*_recAudioFrameSize], pData, framesAvailable*_recAudioFrameSize); 4021 } 4022 else 4023 { 4024 ZeroMemory(&syncBuffer[syncBufIndex*_recAudioFrameSize], framesAvailable*_recAudioFrameSize); 4025 } 4026 assert(syncBufferSize >= (syncBufIndex*_recAudioFrameSize)+framesAvailable*_recAudioFrameSize); 4027 4028 // Release the capture buffer 4029 // 4030 hr = _ptrCaptureClient->ReleaseBuffer(framesAvailable); 4031 EXIT_ON_ERROR(hr); 4032 4033 _readSamples += framesAvailable; 4034 syncBufIndex += framesAvailable; 4035 4036 QueryPerformanceCounter(&t1); 4037 4038 // Get the current recording and playout delay. 4039 uint32_t sndCardRecDelay = (uint32_t) 4040 (((((UINT64)t1.QuadPart * _perfCounterFactor) - recTime) 4041 / 10000) + (10*syncBufIndex) / _recBlockSize - 10); 4042 uint32_t sndCardPlayDelay = 4043 static_cast<uint32_t>(_sndCardPlayDelay); 4044 4045 _sndCardRecDelay = sndCardRecDelay; 4046 4047 while (syncBufIndex >= _recBlockSize) 4048 { 4049 if (_ptrAudioBuffer) 4050 { 4051 _ptrAudioBuffer->SetRecordedBuffer((const int8_t*)syncBuffer, _recBlockSize); 4052 _ptrAudioBuffer->SetVQEData(sndCardPlayDelay, 4053 sndCardRecDelay, 4054 0); 4055 4056 _ptrAudioBuffer->SetTypingStatus(KeyPressed()); 4057 4058 QueryPerformanceCounter(&t1); // measure time: START 4059 4060 _UnLock(); // release lock while making the callback 4061 _ptrAudioBuffer->DeliverRecordedData(); 4062 _Lock(); // restore the lock 4063 4064 QueryPerformanceCounter(&t2); // measure time: STOP 4065 4066 // Measure "average CPU load". 4067 // Basically what we do here is to measure how many percent of our 10ms period 4068 // is used for encoding and decoding. This value shuld be used as a warning indicator 4069 // only and not seen as an absolute value. Running at ~100% will lead to bad QoS. 4070 time = (int)(t2.QuadPart - t1.QuadPart); 4071 _avgCPULoad = (float)(_avgCPULoad*.99 + (time + _playAcc) / (double)(_perfCounterFreq.QuadPart)); 4072 _playAcc = 0; 4073 4074 // Sanity check to ensure that essential states are not modified during the unlocked period 4075 if (_ptrCaptureClient == NULL || _ptrClientIn == NULL) 4076 { 4077 _UnLock(); 4078 WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "input state has been modified during unlocked period"); 4079 goto Exit; 4080 } 4081 } 4082 4083 // store remaining data which was not able to deliver as 10ms segment 4084 MoveMemory(&syncBuffer[0], &syncBuffer[_recBlockSize*_recAudioFrameSize], (syncBufIndex-_recBlockSize)*_recAudioFrameSize); 4085 syncBufIndex -= _recBlockSize; 4086 sndCardRecDelay -= 10; 4087 } 4088 4089 if (_AGC) 4090 { 4091 uint32_t newMicLevel = _ptrAudioBuffer->NewMicLevel(); 4092 if (newMicLevel != 0) 4093 { 4094 // The VQE will only deliver non-zero microphone levels when a change is needed. 4095 // Set this new mic level (received from the observer as return value in the callback). 4096 WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "AGC change of volume: new=%u", newMicLevel); 4097 // We store this outside of the audio buffer to avoid 4098 // having it overwritten by the getter thread. 4099 _newMicLevel = newMicLevel; 4100 SetEvent(_hSetCaptureVolumeEvent); 4101 } 4102 } 4103 } 4104 else 4105 { 4106 // If GetBuffer returns AUDCLNT_E_BUFFER_ERROR, the thread consuming the audio samples 4107 // must wait for the next processing pass. The client might benefit from keeping a count 4108 // of the failed GetBuffer calls. If GetBuffer returns this error repeatedly, the client 4109 // can start a new processing loop after shutting down the current client by calling 4110 // IAudioClient::Stop, IAudioClient::Reset, and releasing the audio client. 4111 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4112 "IAudioCaptureClient::GetBuffer returned AUDCLNT_E_BUFFER_ERROR, hr = 0x%08X", hr); 4113 goto Exit; 4114 } 4115 4116 _UnLock(); 4117 } 4118 } 4119 4120 // ---------------------------- THREAD LOOP ---------------------------- << 4121 4122 hr = _ptrClientIn->Stop(); 4123 4124 Exit: 4125 if (FAILED(hr)) 4126 { 4127 _ptrClientIn->Stop(); 4128 _UnLock(); 4129 _TraceCOMError(hr); 4130 } 4131 4132 RevertCaptureThreadPriority(); 4133 4134 _Lock(); 4135 4136 if (keepRecording) 4137 { 4138 if (_ptrClientIn != NULL) 4139 { 4140 hr = _ptrClientIn->Stop(); 4141 if (FAILED(hr)) 4142 { 4143 _TraceCOMError(hr); 4144 } 4145 hr = _ptrClientIn->Reset(); 4146 if (FAILED(hr)) 4147 { 4148 _TraceCOMError(hr); 4149 } 4150 } 4151 4152 // Trigger callback from module process thread 4153 _recError = 1; 4154 WEBRTC_TRACE(kTraceError, kTraceUtility, _id, "kRecordingError message posted: capturing thread has ended pre-maturely"); 4155 } 4156 else 4157 { 4158 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_Capturing thread is now terminated properly"); 4159 } 4160 4161 SAFE_RELEASE(_ptrClientIn); 4162 SAFE_RELEASE(_ptrCaptureClient); 4163 4164 _UnLock(); 4165 4166 if (syncBuffer) 4167 { 4168 delete [] syncBuffer; 4169 } 4170 4171 return (DWORD)hr; 4172 } 4173 4174 int32_t AudioDeviceWindowsCore::EnableBuiltInAEC(bool enable) 4175 { 4176 4177 if (_recIsInitialized) 4178 { 4179 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4180 "Attempt to set Windows AEC with recording already initialized"); 4181 return -1; 4182 } 4183 4184 if (_dmo == NULL) 4185 { 4186 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4187 "Built-in AEC DMO was not initialized properly at create time"); 4188 return -1; 4189 } 4190 4191 _builtInAecEnabled = enable; 4192 return 0; 4193 } 4194 4195 bool AudioDeviceWindowsCore::BuiltInAECIsEnabled() const 4196 { 4197 return _builtInAecEnabled; 4198 } 4199 4200 int AudioDeviceWindowsCore::SetDMOProperties() 4201 { 4202 HRESULT hr = S_OK; 4203 assert(_dmo != NULL); 4204 4205 scoped_refptr<IPropertyStore> ps; 4206 { 4207 IPropertyStore* ptrPS = NULL; 4208 hr = _dmo->QueryInterface(IID_IPropertyStore, 4209 reinterpret_cast<void**>(&ptrPS)); 4210 if (FAILED(hr) || ptrPS == NULL) 4211 { 4212 _TraceCOMError(hr); 4213 return -1; 4214 } 4215 ps = ptrPS; 4216 SAFE_RELEASE(ptrPS); 4217 } 4218 4219 // Set the AEC system mode. 4220 // SINGLE_CHANNEL_AEC - AEC processing only. 4221 if (SetVtI4Property(ps, 4222 MFPKEY_WMAAECMA_SYSTEM_MODE, 4223 SINGLE_CHANNEL_AEC)) 4224 { 4225 return -1; 4226 } 4227 4228 // Set the AEC source mode. 4229 // VARIANT_TRUE - Source mode (we poll the AEC for captured data). 4230 if (SetBoolProperty(ps, 4231 MFPKEY_WMAAECMA_DMO_SOURCE_MODE, 4232 VARIANT_TRUE) == -1) 4233 { 4234 return -1; 4235 } 4236 4237 // Enable the feature mode. 4238 // This lets us override all the default processing settings below. 4239 if (SetBoolProperty(ps, 4240 MFPKEY_WMAAECMA_FEATURE_MODE, 4241 VARIANT_TRUE) == -1) 4242 { 4243 return -1; 4244 } 4245 4246 // Disable analog AGC (default enabled). 4247 if (SetBoolProperty(ps, 4248 MFPKEY_WMAAECMA_MIC_GAIN_BOUNDER, 4249 VARIANT_FALSE) == -1) 4250 { 4251 return -1; 4252 } 4253 4254 // Disable noise suppression (default enabled). 4255 // 0 - Disabled, 1 - Enabled 4256 if (SetVtI4Property(ps, 4257 MFPKEY_WMAAECMA_FEATR_NS, 4258 0) == -1) 4259 { 4260 return -1; 4261 } 4262 4263 // Relevant parameters to leave at default settings: 4264 // MFPKEY_WMAAECMA_FEATR_AGC - Digital AGC (disabled). 4265 // MFPKEY_WMAAECMA_FEATR_CENTER_CLIP - AEC center clipping (enabled). 4266 // MFPKEY_WMAAECMA_FEATR_ECHO_LENGTH - Filter length (256 ms). 4267 // TODO(andrew): investigate decresing the length to 128 ms. 4268 // MFPKEY_WMAAECMA_FEATR_FRAME_SIZE - Frame size (0). 4269 // 0 is automatic; defaults to 160 samples (or 10 ms frames at the 4270 // selected 16 kHz) as long as mic array processing is disabled. 4271 // MFPKEY_WMAAECMA_FEATR_NOISE_FILL - Comfort noise (enabled). 4272 // MFPKEY_WMAAECMA_FEATR_VAD - VAD (disabled). 4273 4274 // Set the devices selected by VoE. If using a default device, we need to 4275 // search for the device index. 4276 int inDevIndex = _inputDeviceIndex; 4277 int outDevIndex = _outputDeviceIndex; 4278 if (!_usingInputDeviceIndex) 4279 { 4280 ERole role = eCommunications; 4281 if (_inputDevice == AudioDeviceModule::kDefaultDevice) 4282 { 4283 role = eConsole; 4284 } 4285 4286 if (_GetDefaultDeviceIndex(eCapture, role, &inDevIndex) == -1) 4287 { 4288 return -1; 4289 } 4290 } 4291 4292 if (!_usingOutputDeviceIndex) 4293 { 4294 ERole role = eCommunications; 4295 if (_outputDevice == AudioDeviceModule::kDefaultDevice) 4296 { 4297 role = eConsole; 4298 } 4299 4300 if (_GetDefaultDeviceIndex(eRender, role, &outDevIndex) == -1) 4301 { 4302 return -1; 4303 } 4304 } 4305 4306 DWORD devIndex = static_cast<uint32_t>(outDevIndex << 16) + 4307 static_cast<uint32_t>(0x0000ffff & inDevIndex); 4308 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 4309 "Capture device index: %d, render device index: %d", 4310 inDevIndex, outDevIndex); 4311 if (SetVtI4Property(ps, 4312 MFPKEY_WMAAECMA_DEVICE_INDEXES, 4313 devIndex) == -1) 4314 { 4315 return -1; 4316 } 4317 4318 return 0; 4319 } 4320 4321 int AudioDeviceWindowsCore::SetBoolProperty(IPropertyStore* ptrPS, 4322 REFPROPERTYKEY key, 4323 VARIANT_BOOL value) 4324 { 4325 PROPVARIANT pv; 4326 PropVariantInit(&pv); 4327 pv.vt = VT_BOOL; 4328 pv.boolVal = value; 4329 HRESULT hr = ptrPS->SetValue(key, pv); 4330 PropVariantClear(&pv); 4331 if (FAILED(hr)) 4332 { 4333 _TraceCOMError(hr); 4334 return -1; 4335 } 4336 return 0; 4337 } 4338 4339 int AudioDeviceWindowsCore::SetVtI4Property(IPropertyStore* ptrPS, 4340 REFPROPERTYKEY key, 4341 LONG value) 4342 { 4343 PROPVARIANT pv; 4344 PropVariantInit(&pv); 4345 pv.vt = VT_I4; 4346 pv.lVal = value; 4347 HRESULT hr = ptrPS->SetValue(key, pv); 4348 PropVariantClear(&pv); 4349 if (FAILED(hr)) 4350 { 4351 _TraceCOMError(hr); 4352 return -1; 4353 } 4354 return 0; 4355 } 4356 4357 // ---------------------------------------------------------------------------- 4358 // _RefreshDeviceList 4359 // 4360 // Creates a new list of endpoint rendering or capture devices after 4361 // deleting any previously created (and possibly out-of-date) list of 4362 // such devices. 4363 // ---------------------------------------------------------------------------- 4364 4365 int32_t AudioDeviceWindowsCore::_RefreshDeviceList(EDataFlow dir) 4366 { 4367 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4368 4369 HRESULT hr = S_OK; 4370 IMMDeviceCollection *pCollection = NULL; 4371 4372 assert(dir == eRender || dir == eCapture); 4373 assert(_ptrEnumerator != NULL); 4374 4375 // Create a fresh list of devices using the specified direction 4376 hr = _ptrEnumerator->EnumAudioEndpoints( 4377 dir, 4378 DEVICE_STATE_ACTIVE, 4379 &pCollection); 4380 if (FAILED(hr)) 4381 { 4382 _TraceCOMError(hr); 4383 SAFE_RELEASE(pCollection); 4384 return -1; 4385 } 4386 4387 if (dir == eRender) 4388 { 4389 SAFE_RELEASE(_ptrRenderCollection); 4390 _ptrRenderCollection = pCollection; 4391 } 4392 else 4393 { 4394 SAFE_RELEASE(_ptrCaptureCollection); 4395 _ptrCaptureCollection = pCollection; 4396 } 4397 4398 return 0; 4399 } 4400 4401 // ---------------------------------------------------------------------------- 4402 // _DeviceListCount 4403 // 4404 // Gets a count of the endpoint rendering or capture devices in the 4405 // current list of such devices. 4406 // ---------------------------------------------------------------------------- 4407 4408 int16_t AudioDeviceWindowsCore::_DeviceListCount(EDataFlow dir) 4409 { 4410 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4411 4412 HRESULT hr = S_OK; 4413 UINT count = 0; 4414 4415 assert(eRender == dir || eCapture == dir); 4416 4417 if (eRender == dir && NULL != _ptrRenderCollection) 4418 { 4419 hr = _ptrRenderCollection->GetCount(&count); 4420 } 4421 else if (NULL != _ptrCaptureCollection) 4422 { 4423 hr = _ptrCaptureCollection->GetCount(&count); 4424 } 4425 4426 if (FAILED(hr)) 4427 { 4428 _TraceCOMError(hr); 4429 return -1; 4430 } 4431 4432 return static_cast<int16_t> (count); 4433 } 4434 4435 // ---------------------------------------------------------------------------- 4436 // _GetListDeviceName 4437 // 4438 // Gets the friendly name of an endpoint rendering or capture device 4439 // from the current list of such devices. The caller uses an index 4440 // into the list to identify the device. 4441 // 4442 // Uses: _ptrRenderCollection or _ptrCaptureCollection which is updated 4443 // in _RefreshDeviceList(). 4444 // ---------------------------------------------------------------------------- 4445 4446 int32_t AudioDeviceWindowsCore::_GetListDeviceName(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen) 4447 { 4448 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4449 4450 HRESULT hr = S_OK; 4451 IMMDevice *pDevice = NULL; 4452 4453 assert(dir == eRender || dir == eCapture); 4454 4455 if (eRender == dir && NULL != _ptrRenderCollection) 4456 { 4457 hr = _ptrRenderCollection->Item(index, &pDevice); 4458 } 4459 else if (NULL != _ptrCaptureCollection) 4460 { 4461 hr = _ptrCaptureCollection->Item(index, &pDevice); 4462 } 4463 4464 if (FAILED(hr)) 4465 { 4466 _TraceCOMError(hr); 4467 SAFE_RELEASE(pDevice); 4468 return -1; 4469 } 4470 4471 int32_t res = _GetDeviceName(pDevice, szBuffer, bufferLen); 4472 SAFE_RELEASE(pDevice); 4473 return res; 4474 } 4475 4476 // ---------------------------------------------------------------------------- 4477 // _GetDefaultDeviceName 4478 // 4479 // Gets the friendly name of an endpoint rendering or capture device 4480 // given a specified device role. 4481 // 4482 // Uses: _ptrEnumerator 4483 // ---------------------------------------------------------------------------- 4484 4485 int32_t AudioDeviceWindowsCore::_GetDefaultDeviceName(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen) 4486 { 4487 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4488 4489 HRESULT hr = S_OK; 4490 IMMDevice *pDevice = NULL; 4491 4492 assert(dir == eRender || dir == eCapture); 4493 assert(role == eConsole || role == eCommunications); 4494 assert(_ptrEnumerator != NULL); 4495 4496 hr = _ptrEnumerator->GetDefaultAudioEndpoint( 4497 dir, 4498 role, 4499 &pDevice); 4500 4501 if (FAILED(hr)) 4502 { 4503 _TraceCOMError(hr); 4504 SAFE_RELEASE(pDevice); 4505 return -1; 4506 } 4507 4508 int32_t res = _GetDeviceName(pDevice, szBuffer, bufferLen); 4509 SAFE_RELEASE(pDevice); 4510 return res; 4511 } 4512 4513 // ---------------------------------------------------------------------------- 4514 // _GetListDeviceID 4515 // 4516 // Gets the unique ID string of an endpoint rendering or capture device 4517 // from the current list of such devices. The caller uses an index 4518 // into the list to identify the device. 4519 // 4520 // Uses: _ptrRenderCollection or _ptrCaptureCollection which is updated 4521 // in _RefreshDeviceList(). 4522 // ---------------------------------------------------------------------------- 4523 4524 int32_t AudioDeviceWindowsCore::_GetListDeviceID(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen) 4525 { 4526 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4527 4528 HRESULT hr = S_OK; 4529 IMMDevice *pDevice = NULL; 4530 4531 assert(dir == eRender || dir == eCapture); 4532 4533 if (eRender == dir && NULL != _ptrRenderCollection) 4534 { 4535 hr = _ptrRenderCollection->Item(index, &pDevice); 4536 } 4537 else if (NULL != _ptrCaptureCollection) 4538 { 4539 hr = _ptrCaptureCollection->Item(index, &pDevice); 4540 } 4541 4542 if (FAILED(hr)) 4543 { 4544 _TraceCOMError(hr); 4545 SAFE_RELEASE(pDevice); 4546 return -1; 4547 } 4548 4549 int32_t res = _GetDeviceID(pDevice, szBuffer, bufferLen); 4550 SAFE_RELEASE(pDevice); 4551 return res; 4552 } 4553 4554 // ---------------------------------------------------------------------------- 4555 // _GetDefaultDeviceID 4556 // 4557 // Gets the uniqe device ID of an endpoint rendering or capture device 4558 // given a specified device role. 4559 // 4560 // Uses: _ptrEnumerator 4561 // ---------------------------------------------------------------------------- 4562 4563 int32_t AudioDeviceWindowsCore::_GetDefaultDeviceID(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen) 4564 { 4565 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4566 4567 HRESULT hr = S_OK; 4568 IMMDevice *pDevice = NULL; 4569 4570 assert(dir == eRender || dir == eCapture); 4571 assert(role == eConsole || role == eCommunications); 4572 assert(_ptrEnumerator != NULL); 4573 4574 hr = _ptrEnumerator->GetDefaultAudioEndpoint( 4575 dir, 4576 role, 4577 &pDevice); 4578 4579 if (FAILED(hr)) 4580 { 4581 _TraceCOMError(hr); 4582 SAFE_RELEASE(pDevice); 4583 return -1; 4584 } 4585 4586 int32_t res = _GetDeviceID(pDevice, szBuffer, bufferLen); 4587 SAFE_RELEASE(pDevice); 4588 return res; 4589 } 4590 4591 int32_t AudioDeviceWindowsCore::_GetDefaultDeviceIndex(EDataFlow dir, 4592 ERole role, 4593 int* index) 4594 { 4595 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4596 4597 HRESULT hr = S_OK; 4598 WCHAR szDefaultDeviceID[MAX_PATH] = {0}; 4599 WCHAR szDeviceID[MAX_PATH] = {0}; 4600 4601 const size_t kDeviceIDLength = sizeof(szDeviceID)/sizeof(szDeviceID[0]); 4602 assert(kDeviceIDLength == 4603 sizeof(szDefaultDeviceID) / sizeof(szDefaultDeviceID[0])); 4604 4605 if (_GetDefaultDeviceID(dir, 4606 role, 4607 szDefaultDeviceID, 4608 kDeviceIDLength) == -1) 4609 { 4610 return -1; 4611 } 4612 4613 IMMDeviceCollection* collection = _ptrCaptureCollection; 4614 if (dir == eRender) 4615 { 4616 collection = _ptrRenderCollection; 4617 } 4618 4619 if (!collection) 4620 { 4621 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4622 "Device collection not valid"); 4623 return -1; 4624 } 4625 4626 UINT count = 0; 4627 hr = collection->GetCount(&count); 4628 if (FAILED(hr)) 4629 { 4630 _TraceCOMError(hr); 4631 return -1; 4632 } 4633 4634 *index = -1; 4635 for (UINT i = 0; i < count; i++) 4636 { 4637 memset(szDeviceID, 0, sizeof(szDeviceID)); 4638 scoped_refptr<IMMDevice> device; 4639 { 4640 IMMDevice* ptrDevice = NULL; 4641 hr = collection->Item(i, &ptrDevice); 4642 if (FAILED(hr) || ptrDevice == NULL) 4643 { 4644 _TraceCOMError(hr); 4645 return -1; 4646 } 4647 device = ptrDevice; 4648 SAFE_RELEASE(ptrDevice); 4649 } 4650 4651 if (_GetDeviceID(device, szDeviceID, kDeviceIDLength) == -1) 4652 { 4653 return -1; 4654 } 4655 4656 if (wcsncmp(szDefaultDeviceID, szDeviceID, kDeviceIDLength) == 0) 4657 { 4658 // Found a match. 4659 *index = i; 4660 break; 4661 } 4662 4663 } 4664 4665 if (*index == -1) 4666 { 4667 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4668 "Unable to find collection index for default device"); 4669 return -1; 4670 } 4671 4672 return 0; 4673 } 4674 4675 // ---------------------------------------------------------------------------- 4676 // _GetDeviceName 4677 // ---------------------------------------------------------------------------- 4678 4679 int32_t AudioDeviceWindowsCore::_GetDeviceName(IMMDevice* pDevice, 4680 LPWSTR pszBuffer, 4681 int bufferLen) 4682 { 4683 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4684 4685 static const WCHAR szDefault[] = L"<Device not available>"; 4686 4687 HRESULT hr = E_FAIL; 4688 IPropertyStore *pProps = NULL; 4689 PROPVARIANT varName; 4690 4691 assert(pszBuffer != NULL); 4692 assert(bufferLen > 0); 4693 4694 if (pDevice != NULL) 4695 { 4696 hr = pDevice->OpenPropertyStore(STGM_READ, &pProps); 4697 if (FAILED(hr)) 4698 { 4699 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4700 "IMMDevice::OpenPropertyStore failed, hr = 0x%08X", hr); 4701 } 4702 } 4703 4704 // Initialize container for property value. 4705 PropVariantInit(&varName); 4706 4707 if (SUCCEEDED(hr)) 4708 { 4709 // Get the endpoint device's friendly-name property. 4710 hr = pProps->GetValue(PKEY_Device_FriendlyName, &varName); 4711 if (FAILED(hr)) 4712 { 4713 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4714 "IPropertyStore::GetValue failed, hr = 0x%08X", hr); 4715 } 4716 } 4717 4718 if ((SUCCEEDED(hr)) && (VT_EMPTY == varName.vt)) 4719 { 4720 hr = E_FAIL; 4721 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4722 "IPropertyStore::GetValue returned no value, hr = 0x%08X", hr); 4723 } 4724 4725 if ((SUCCEEDED(hr)) && (VT_LPWSTR != varName.vt)) 4726 { 4727 // The returned value is not a wide null terminated string. 4728 hr = E_UNEXPECTED; 4729 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 4730 "IPropertyStore::GetValue returned unexpected type, hr = 0x%08X", hr); 4731 } 4732 4733 if (SUCCEEDED(hr) && (varName.pwszVal != NULL)) 4734 { 4735 // Copy the valid device name to the provided ouput buffer. 4736 wcsncpy_s(pszBuffer, bufferLen, varName.pwszVal, _TRUNCATE); 4737 } 4738 else 4739 { 4740 // Failed to find the device name. 4741 wcsncpy_s(pszBuffer, bufferLen, szDefault, _TRUNCATE); 4742 } 4743 4744 PropVariantClear(&varName); 4745 SAFE_RELEASE(pProps); 4746 4747 return 0; 4748 } 4749 4750 // ---------------------------------------------------------------------------- 4751 // _GetDeviceID 4752 // ---------------------------------------------------------------------------- 4753 4754 int32_t AudioDeviceWindowsCore::_GetDeviceID(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen) 4755 { 4756 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4757 4758 static const WCHAR szDefault[] = L"<Device not available>"; 4759 4760 HRESULT hr = E_FAIL; 4761 LPWSTR pwszID = NULL; 4762 4763 assert(pszBuffer != NULL); 4764 assert(bufferLen > 0); 4765 4766 if (pDevice != NULL) 4767 { 4768 hr = pDevice->GetId(&pwszID); 4769 } 4770 4771 if (hr == S_OK) 4772 { 4773 // Found the device ID. 4774 wcsncpy_s(pszBuffer, bufferLen, pwszID, _TRUNCATE); 4775 } 4776 else 4777 { 4778 // Failed to find the device ID. 4779 wcsncpy_s(pszBuffer, bufferLen, szDefault, _TRUNCATE); 4780 } 4781 4782 CoTaskMemFree(pwszID); 4783 return 0; 4784 } 4785 4786 // ---------------------------------------------------------------------------- 4787 // _GetDefaultDevice 4788 // ---------------------------------------------------------------------------- 4789 4790 int32_t AudioDeviceWindowsCore::_GetDefaultDevice(EDataFlow dir, ERole role, IMMDevice** ppDevice) 4791 { 4792 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4793 4794 HRESULT hr(S_OK); 4795 4796 assert(_ptrEnumerator != NULL); 4797 4798 hr = _ptrEnumerator->GetDefaultAudioEndpoint( 4799 dir, 4800 role, 4801 ppDevice); 4802 if (FAILED(hr)) 4803 { 4804 _TraceCOMError(hr); 4805 return -1; 4806 } 4807 4808 return 0; 4809 } 4810 4811 // ---------------------------------------------------------------------------- 4812 // _GetListDevice 4813 // ---------------------------------------------------------------------------- 4814 4815 int32_t AudioDeviceWindowsCore::_GetListDevice(EDataFlow dir, int index, IMMDevice** ppDevice) 4816 { 4817 HRESULT hr(S_OK); 4818 4819 assert(_ptrEnumerator != NULL); 4820 4821 IMMDeviceCollection *pCollection = NULL; 4822 4823 hr = _ptrEnumerator->EnumAudioEndpoints( 4824 dir, 4825 DEVICE_STATE_ACTIVE, // only active endpoints are OK 4826 &pCollection); 4827 if (FAILED(hr)) 4828 { 4829 _TraceCOMError(hr); 4830 SAFE_RELEASE(pCollection); 4831 return -1; 4832 } 4833 4834 hr = pCollection->Item( 4835 index, 4836 ppDevice); 4837 if (FAILED(hr)) 4838 { 4839 _TraceCOMError(hr); 4840 SAFE_RELEASE(pCollection); 4841 return -1; 4842 } 4843 4844 return 0; 4845 } 4846 4847 // ---------------------------------------------------------------------------- 4848 // _EnumerateEndpointDevicesAll 4849 // ---------------------------------------------------------------------------- 4850 4851 int32_t AudioDeviceWindowsCore::_EnumerateEndpointDevicesAll(EDataFlow dataFlow) const 4852 { 4853 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); 4854 4855 assert(_ptrEnumerator != NULL); 4856 4857 HRESULT hr = S_OK; 4858 IMMDeviceCollection *pCollection = NULL; 4859 IMMDevice *pEndpoint = NULL; 4860 IPropertyStore *pProps = NULL; 4861 IAudioEndpointVolume* pEndpointVolume = NULL; 4862 LPWSTR pwszID = NULL; 4863 4864 // Generate a collection of audio endpoint devices in the system. 4865 // Get states for *all* endpoint devices. 4866 // Output: IMMDeviceCollection interface. 4867 hr = _ptrEnumerator->EnumAudioEndpoints( 4868 dataFlow, // data-flow direction (input parameter) 4869 DEVICE_STATE_ACTIVE | DEVICE_STATE_DISABLED | DEVICE_STATE_UNPLUGGED, 4870 &pCollection); // release interface when done 4871 4872 EXIT_ON_ERROR(hr); 4873 4874 // use the IMMDeviceCollection interface... 4875 4876 UINT count = 0; 4877 4878 // Retrieve a count of the devices in the device collection. 4879 hr = pCollection->GetCount(&count); 4880 EXIT_ON_ERROR(hr); 4881 if (dataFlow == eRender) 4882 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#rendering endpoint devices (counting all): %u", count); 4883 else if (dataFlow == eCapture) 4884 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#capturing endpoint devices (counting all): %u", count); 4885 4886 if (count == 0) 4887 { 4888 return 0; 4889 } 4890 4891 // Each loop prints the name of an endpoint device. 4892 for (ULONG i = 0; i < count; i++) 4893 { 4894 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Endpoint %d:", i); 4895 4896 // Get pointer to endpoint number i. 4897 // Output: IMMDevice interface. 4898 hr = pCollection->Item( 4899 i, 4900 &pEndpoint); 4901 CONTINUE_ON_ERROR(hr); 4902 4903 // use the IMMDevice interface of the specified endpoint device... 4904 4905 // Get the endpoint ID string (uniquely identifies the device among all audio endpoint devices) 4906 hr = pEndpoint->GetId(&pwszID); 4907 CONTINUE_ON_ERROR(hr); 4908 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "ID string : %S", pwszID); 4909 4910 // Retrieve an interface to the device's property store. 4911 // Output: IPropertyStore interface. 4912 hr = pEndpoint->OpenPropertyStore( 4913 STGM_READ, 4914 &pProps); 4915 CONTINUE_ON_ERROR(hr); 4916 4917 // use the IPropertyStore interface... 4918 4919 PROPVARIANT varName; 4920 // Initialize container for property value. 4921 PropVariantInit(&varName); 4922 4923 // Get the endpoint's friendly-name property. 4924 // Example: "Speakers (Realtek High Definition Audio)" 4925 hr = pProps->GetValue( 4926 PKEY_Device_FriendlyName, 4927 &varName); 4928 CONTINUE_ON_ERROR(hr); 4929 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "friendly name: \"%S\"", varName.pwszVal); 4930 4931 // Get the endpoint's current device state 4932 DWORD dwState; 4933 hr = pEndpoint->GetState(&dwState); 4934 CONTINUE_ON_ERROR(hr); 4935 if (dwState & DEVICE_STATE_ACTIVE) 4936 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "state (0x%x) : *ACTIVE*", dwState); 4937 if (dwState & DEVICE_STATE_DISABLED) 4938 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "state (0x%x) : DISABLED", dwState); 4939 if (dwState & DEVICE_STATE_NOTPRESENT) 4940 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "state (0x%x) : NOTPRESENT", dwState); 4941 if (dwState & DEVICE_STATE_UNPLUGGED) 4942 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "state (0x%x) : UNPLUGGED", dwState); 4943 4944 // Check the hardware volume capabilities. 4945 DWORD dwHwSupportMask = 0; 4946 hr = pEndpoint->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, 4947 NULL, (void**)&pEndpointVolume); 4948 CONTINUE_ON_ERROR(hr); 4949 hr = pEndpointVolume->QueryHardwareSupport(&dwHwSupportMask); 4950 CONTINUE_ON_ERROR(hr); 4951 if (dwHwSupportMask & ENDPOINT_HARDWARE_SUPPORT_VOLUME) 4952 // The audio endpoint device supports a hardware volume control 4953 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "hwmask (0x%x) : HARDWARE_SUPPORT_VOLUME", dwHwSupportMask); 4954 if (dwHwSupportMask & ENDPOINT_HARDWARE_SUPPORT_MUTE) 4955 // The audio endpoint device supports a hardware mute control 4956 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "hwmask (0x%x) : HARDWARE_SUPPORT_MUTE", dwHwSupportMask); 4957 if (dwHwSupportMask & ENDPOINT_HARDWARE_SUPPORT_METER) 4958 // The audio endpoint device supports a hardware peak meter 4959 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "hwmask (0x%x) : HARDWARE_SUPPORT_METER", dwHwSupportMask); 4960 4961 // Check the channel count (#channels in the audio stream that enters or leaves the audio endpoint device) 4962 UINT nChannelCount(0); 4963 hr = pEndpointVolume->GetChannelCount( 4964 &nChannelCount); 4965 CONTINUE_ON_ERROR(hr); 4966 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#channels : %u", nChannelCount); 4967 4968 if (dwHwSupportMask & ENDPOINT_HARDWARE_SUPPORT_VOLUME) 4969 { 4970 // Get the volume range. 4971 float fLevelMinDB(0.0); 4972 float fLevelMaxDB(0.0); 4973 float fVolumeIncrementDB(0.0); 4974 hr = pEndpointVolume->GetVolumeRange( 4975 &fLevelMinDB, 4976 &fLevelMaxDB, 4977 &fVolumeIncrementDB); 4978 CONTINUE_ON_ERROR(hr); 4979 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "volume range : %4.2f (min), %4.2f (max), %4.2f (inc) [dB]", 4980 fLevelMinDB, fLevelMaxDB, fVolumeIncrementDB); 4981 4982 // The volume range from vmin = fLevelMinDB to vmax = fLevelMaxDB is divided 4983 // into n uniform intervals of size vinc = fVolumeIncrementDB, where 4984 // n = (vmax ?vmin) / vinc. 4985 // The values vmin, vmax, and vinc are measured in decibels. The client can set 4986 // the volume level to one of n + 1 discrete values in the range from vmin to vmax. 4987 int n = (int)((fLevelMaxDB-fLevelMinDB)/fVolumeIncrementDB); 4988 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#intervals : %d", n); 4989 4990 // Get information about the current step in the volume range. 4991 // This method represents the volume level of the audio stream that enters or leaves 4992 // the audio endpoint device as an index or "step" in a range of discrete volume levels. 4993 // Output value nStepCount is the number of steps in the range. Output value nStep 4994 // is the step index of the current volume level. If the number of steps is n = nStepCount, 4995 // then step index nStep can assume values from 0 (minimum volume) to n ?1 (maximum volume). 4996 UINT nStep(0); 4997 UINT nStepCount(0); 4998 hr = pEndpointVolume->GetVolumeStepInfo( 4999 &nStep, 5000 &nStepCount); 5001 CONTINUE_ON_ERROR(hr); 5002 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "volume steps : %d (nStep), %d (nStepCount)", nStep, nStepCount); 5003 } 5004 Next: 5005 if (FAILED(hr)) { 5006 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, 5007 "Error when logging device information"); 5008 } 5009 CoTaskMemFree(pwszID); 5010 pwszID = NULL; 5011 PropVariantClear(&varName); 5012 SAFE_RELEASE(pProps); 5013 SAFE_RELEASE(pEndpoint); 5014 SAFE_RELEASE(pEndpointVolume); 5015 } 5016 SAFE_RELEASE(pCollection); 5017 return 0; 5018 5019 Exit: 5020 _TraceCOMError(hr); 5021 CoTaskMemFree(pwszID); 5022 pwszID = NULL; 5023 SAFE_RELEASE(pCollection); 5024 SAFE_RELEASE(pEndpoint); 5025 SAFE_RELEASE(pEndpointVolume); 5026 SAFE_RELEASE(pProps); 5027 return -1; 5028 } 5029 5030 // ---------------------------------------------------------------------------- 5031 // _TraceCOMError 5032 // ---------------------------------------------------------------------------- 5033 5034 void AudioDeviceWindowsCore::_TraceCOMError(HRESULT hr) const 5035 { 5036 TCHAR buf[MAXERRORLENGTH]; 5037 TCHAR errorText[MAXERRORLENGTH]; 5038 5039 const DWORD dwFlags = FORMAT_MESSAGE_FROM_SYSTEM | 5040 FORMAT_MESSAGE_IGNORE_INSERTS; 5041 const DWORD dwLangID = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US); 5042 5043 // Gets the system's human readable message string for this HRESULT. 5044 // All error message in English by default. 5045 DWORD messageLength = ::FormatMessageW(dwFlags, 5046 0, 5047 hr, 5048 dwLangID, 5049 errorText, 5050 MAXERRORLENGTH, 5051 NULL); 5052 5053 assert(messageLength <= MAXERRORLENGTH); 5054 5055 // Trims tailing white space (FormatMessage() leaves a trailing cr-lf.). 5056 for (; messageLength && ::isspace(errorText[messageLength - 1]); 5057 --messageLength) 5058 { 5059 errorText[messageLength - 1] = '\0'; 5060 } 5061 5062 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, 5063 "Core Audio method failed (hr=0x%x)", hr); 5064 StringCchPrintf(buf, MAXERRORLENGTH, TEXT("Error details: ")); 5065 StringCchCat(buf, MAXERRORLENGTH, errorText); 5066 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "%s", WideToUTF8(buf)); 5067 } 5068 5069 // ---------------------------------------------------------------------------- 5070 // _SetThreadName 5071 // ---------------------------------------------------------------------------- 5072 5073 void AudioDeviceWindowsCore::_SetThreadName(DWORD dwThreadID, LPCSTR szThreadName) 5074 { 5075 // See http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.71).aspx for details on the code 5076 // in this function. Name of article is "Setting a Thread Name (Unmanaged)". 5077 5078 THREADNAME_INFO info; 5079 info.dwType = 0x1000; 5080 info.szName = szThreadName; 5081 info.dwThreadID = dwThreadID; 5082 info.dwFlags = 0; 5083 5084 __try 5085 { 5086 RaiseException( 0x406D1388, 0, sizeof(info)/sizeof(DWORD), (ULONG_PTR *)&info ); 5087 } 5088 __except (EXCEPTION_CONTINUE_EXECUTION) 5089 { 5090 } 5091 } 5092 5093 // ---------------------------------------------------------------------------- 5094 // WideToUTF8 5095 // ---------------------------------------------------------------------------- 5096 5097 char* AudioDeviceWindowsCore::WideToUTF8(const TCHAR* src) const { 5098 #ifdef UNICODE 5099 const size_t kStrLen = sizeof(_str); 5100 memset(_str, 0, kStrLen); 5101 // Get required size (in bytes) to be able to complete the conversion. 5102 int required_size = WideCharToMultiByte(CP_UTF8, 0, src, -1, _str, 0, 0, 0); 5103 if (required_size <= kStrLen) 5104 { 5105 // Process the entire input string, including the terminating null char. 5106 if (WideCharToMultiByte(CP_UTF8, 0, src, -1, _str, kStrLen, 0, 0) == 0) 5107 memset(_str, 0, kStrLen); 5108 } 5109 return _str; 5110 #else 5111 return const_cast<char*>(src); 5112 #endif 5113 } 5114 5115 5116 bool AudioDeviceWindowsCore::KeyPressed() const{ 5117 5118 int key_down = 0; 5119 for (int key = VK_SPACE; key < VK_NUMLOCK; key++) { 5120 short res = GetAsyncKeyState(key); 5121 key_down |= res & 0x1; // Get the LSB 5122 } 5123 return (key_down > 0); 5124 } 5125 } // namespace webrtc 5126 5127 #endif // WEBRTC_WINDOWS_CORE_AUDIO_BUILD 5128
