1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "media/audio/win/core_audio_util_win.h" 6 7 #include <audioclient.h> 8 #include <devicetopology.h> 9 #include <functiondiscoverykeys_devpkey.h> 10 11 #include "base/command_line.h" 12 #include "base/logging.h" 13 #include "base/strings/stringprintf.h" 14 #include "base/strings/utf_string_conversions.h" 15 #include "base/win/scoped_co_mem.h" 16 #include "base/win/scoped_handle.h" 17 #include "base/win/scoped_propvariant.h" 18 #include "base/win/windows_version.h" 19 #include "media/base/media_switches.h" 20 21 using base::win::ScopedCoMem; 22 using base::win::ScopedHandle; 23 24 namespace media { 25 26 // See header file for documentation. 27 // {BE39AF4F-087C-423F-9303-234EC1E5B8EE} 28 const GUID kCommunicationsSessionId = { 29 0xbe39af4f, 0x87c, 0x423f, { 0x93, 0x3, 0x23, 0x4e, 0xc1, 0xe5, 0xb8, 0xee } 30 }; 31 32 enum { KSAUDIO_SPEAKER_UNSUPPORTED = 0 }; 33 34 // Converts Microsoft's channel configuration to ChannelLayout. 35 // This mapping is not perfect but the best we can do given the current 36 // ChannelLayout enumerator and the Windows-specific speaker configurations 37 // defined in ksmedia.h. Don't assume that the channel ordering in 38 // ChannelLayout is exactly the same as the Windows specific configuration. 39 // As an example: KSAUDIO_SPEAKER_7POINT1_SURROUND is mapped to 40 // CHANNEL_LAYOUT_7_1 but the positions of Back L, Back R and Side L, Side R 41 // speakers are different in these two definitions. 42 static ChannelLayout ChannelConfigToChannelLayout(ChannelConfig config) { 43 switch (config) { 44 case KSAUDIO_SPEAKER_DIRECTOUT: 45 DVLOG(2) << "KSAUDIO_SPEAKER_DIRECTOUT=>CHANNEL_LAYOUT_NONE"; 46 return CHANNEL_LAYOUT_NONE; 47 case KSAUDIO_SPEAKER_MONO: 48 DVLOG(2) << "KSAUDIO_SPEAKER_MONO=>CHANNEL_LAYOUT_MONO"; 49 return CHANNEL_LAYOUT_MONO; 50 case KSAUDIO_SPEAKER_STEREO: 51 DVLOG(2) << "KSAUDIO_SPEAKER_STEREO=>CHANNEL_LAYOUT_STEREO"; 52 return CHANNEL_LAYOUT_STEREO; 53 case KSAUDIO_SPEAKER_QUAD: 54 DVLOG(2) << "KSAUDIO_SPEAKER_QUAD=>CHANNEL_LAYOUT_QUAD"; 55 return CHANNEL_LAYOUT_QUAD; 56 case KSAUDIO_SPEAKER_SURROUND: 57 DVLOG(2) << "KSAUDIO_SPEAKER_SURROUND=>CHANNEL_LAYOUT_4_0"; 58 return CHANNEL_LAYOUT_4_0; 59 case KSAUDIO_SPEAKER_5POINT1: 60 DVLOG(2) << "KSAUDIO_SPEAKER_5POINT1=>CHANNEL_LAYOUT_5_1_BACK"; 61 return CHANNEL_LAYOUT_5_1_BACK; 62 case KSAUDIO_SPEAKER_5POINT1_SURROUND: 63 DVLOG(2) << "KSAUDIO_SPEAKER_5POINT1_SURROUND=>CHANNEL_LAYOUT_5_1"; 64 return CHANNEL_LAYOUT_5_1; 65 case KSAUDIO_SPEAKER_7POINT1: 66 DVLOG(2) << "KSAUDIO_SPEAKER_7POINT1=>CHANNEL_LAYOUT_7_1_WIDE"; 67 return CHANNEL_LAYOUT_7_1_WIDE; 68 case KSAUDIO_SPEAKER_7POINT1_SURROUND: 69 DVLOG(2) << "KSAUDIO_SPEAKER_7POINT1_SURROUND=>CHANNEL_LAYOUT_7_1"; 70 return CHANNEL_LAYOUT_7_1; 71 default: 72 DVLOG(2) << "Unsupported channel configuration: " << config; 73 return CHANNEL_LAYOUT_UNSUPPORTED; 74 } 75 } 76 77 // TODO(henrika): add mapping for all types in the ChannelLayout enumerator. 78 static ChannelConfig ChannelLayoutToChannelConfig(ChannelLayout layout) { 79 switch (layout) { 80 case CHANNEL_LAYOUT_NONE: 81 DVLOG(2) << "CHANNEL_LAYOUT_NONE=>KSAUDIO_SPEAKER_UNSUPPORTED"; 82 return KSAUDIO_SPEAKER_UNSUPPORTED; 83 case CHANNEL_LAYOUT_UNSUPPORTED: 84 DVLOG(2) << "CHANNEL_LAYOUT_UNSUPPORTED=>KSAUDIO_SPEAKER_UNSUPPORTED"; 85 return KSAUDIO_SPEAKER_UNSUPPORTED; 86 case CHANNEL_LAYOUT_MONO: 87 DVLOG(2) << "CHANNEL_LAYOUT_MONO=>KSAUDIO_SPEAKER_MONO"; 88 return KSAUDIO_SPEAKER_MONO; 89 case CHANNEL_LAYOUT_STEREO: 90 DVLOG(2) << "CHANNEL_LAYOUT_STEREO=>KSAUDIO_SPEAKER_STEREO"; 91 return KSAUDIO_SPEAKER_STEREO; 92 case CHANNEL_LAYOUT_QUAD: 93 DVLOG(2) << "CHANNEL_LAYOUT_QUAD=>KSAUDIO_SPEAKER_QUAD"; 94 return KSAUDIO_SPEAKER_QUAD; 95 case CHANNEL_LAYOUT_4_0: 96 DVLOG(2) << "CHANNEL_LAYOUT_4_0=>KSAUDIO_SPEAKER_SURROUND"; 97 return KSAUDIO_SPEAKER_SURROUND; 98 case CHANNEL_LAYOUT_5_1_BACK: 99 DVLOG(2) << "CHANNEL_LAYOUT_5_1_BACK=>KSAUDIO_SPEAKER_5POINT1"; 100 return KSAUDIO_SPEAKER_5POINT1; 101 case CHANNEL_LAYOUT_5_1: 102 DVLOG(2) << "CHANNEL_LAYOUT_5_1=>KSAUDIO_SPEAKER_5POINT1_SURROUND"; 103 return KSAUDIO_SPEAKER_5POINT1_SURROUND; 104 case CHANNEL_LAYOUT_7_1_WIDE: 105 DVLOG(2) << "CHANNEL_LAYOUT_7_1_WIDE=>KSAUDIO_SPEAKER_7POINT1"; 106 return KSAUDIO_SPEAKER_7POINT1; 107 case CHANNEL_LAYOUT_7_1: 108 DVLOG(2) << "CHANNEL_LAYOUT_7_1=>KSAUDIO_SPEAKER_7POINT1_SURROUND"; 109 return KSAUDIO_SPEAKER_7POINT1_SURROUND; 110 default: 111 DVLOG(2) << "Unsupported channel layout: " << layout; 112 return KSAUDIO_SPEAKER_UNSUPPORTED; 113 } 114 } 115 116 static std::ostream& operator<<(std::ostream& os, 117 const WAVEFORMATPCMEX& format) { 118 os << "wFormatTag: 0x" << std::hex << format.Format.wFormatTag 119 << ", nChannels: " << std::dec << format.Format.nChannels 120 << ", nSamplesPerSec: " << format.Format.nSamplesPerSec 121 << ", nAvgBytesPerSec: " << format.Format.nAvgBytesPerSec 122 << ", nBlockAlign: " << format.Format.nBlockAlign 123 << ", wBitsPerSample: " << format.Format.wBitsPerSample 124 << ", cbSize: " << format.Format.cbSize 125 << ", wValidBitsPerSample: " << format.Samples.wValidBitsPerSample 126 << ", dwChannelMask: 0x" << std::hex << format.dwChannelMask; 127 return os; 128 } 129 130 static bool LoadAudiosesDll() { 131 static const wchar_t* const kAudiosesDLL = 132 L"%WINDIR%\\system32\\audioses.dll"; 133 134 wchar_t path[MAX_PATH] = {0}; 135 ExpandEnvironmentStringsW(kAudiosesDLL, path, arraysize(path)); 136 return (LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH) != NULL); 137 } 138 139 static bool CanCreateDeviceEnumerator() { 140 ScopedComPtr<IMMDeviceEnumerator> device_enumerator; 141 HRESULT hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), 142 NULL, CLSCTX_INPROC_SERVER); 143 144 // If we hit CO_E_NOTINITIALIZED, CoInitialize has not been called and it 145 // must be called at least once for each thread that uses the COM library. 146 CHECK_NE(hr, CO_E_NOTINITIALIZED); 147 148 return SUCCEEDED(hr); 149 } 150 151 static std::string GetDeviceID(IMMDevice* device) { 152 ScopedCoMem<WCHAR> device_id_com; 153 std::string device_id; 154 if (SUCCEEDED(device->GetId(&device_id_com))) 155 base::WideToUTF8(device_id_com, wcslen(device_id_com), &device_id); 156 return device_id; 157 } 158 159 bool CoreAudioUtil::IsSupported() { 160 // It is possible to force usage of WaveXxx APIs by using a command line flag. 161 const CommandLine* cmd_line = CommandLine::ForCurrentProcess(); 162 if (cmd_line->HasSwitch(switches::kForceWaveAudio)) { 163 DVLOG(1) << "Forcing usage of Windows WaveXxx APIs"; 164 return false; 165 } 166 167 // Microsoft does not plan to make the Core Audio APIs available for use 168 // with earlier versions of Windows, including Microsoft Windows Server 2003, 169 // Windows XP, Windows Millennium Edition, Windows 2000, and Windows 98. 170 if (base::win::GetVersion() < base::win::VERSION_VISTA) 171 return false; 172 173 // The audio core APIs are implemented in the Mmdevapi.dll and Audioses.dll 174 // system components. 175 // Dependency Walker shows that it is enough to verify possibility to load 176 // the Audioses DLL since it depends on Mmdevapi.dll. 177 // See http://crbug.com/166397 why this extra step is required to guarantee 178 // Core Audio support. 179 static bool g_audioses_dll_available = LoadAudiosesDll(); 180 if (!g_audioses_dll_available) 181 return false; 182 183 // Being able to load the Audioses.dll does not seem to be sufficient for 184 // all devices to guarantee Core Audio support. To be 100%, we also verify 185 // that it is possible to a create the IMMDeviceEnumerator interface. If this 186 // works as well we should be home free. 187 static bool g_can_create_device_enumerator = CanCreateDeviceEnumerator(); 188 LOG_IF(ERROR, !g_can_create_device_enumerator) 189 << "Failed to create Core Audio device enumerator on thread with ID " 190 << GetCurrentThreadId(); 191 return g_can_create_device_enumerator; 192 } 193 194 base::TimeDelta CoreAudioUtil::RefererenceTimeToTimeDelta(REFERENCE_TIME time) { 195 // Each unit of reference time is 100 nanoseconds <=> 0.1 microsecond. 196 return base::TimeDelta::FromMicroseconds(0.1 * time + 0.5); 197 } 198 199 AUDCLNT_SHAREMODE CoreAudioUtil::GetShareMode() { 200 const CommandLine* cmd_line = CommandLine::ForCurrentProcess(); 201 if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio)) 202 return AUDCLNT_SHAREMODE_EXCLUSIVE; 203 return AUDCLNT_SHAREMODE_SHARED; 204 } 205 206 int CoreAudioUtil::NumberOfActiveDevices(EDataFlow data_flow) { 207 DCHECK(IsSupported()); 208 // Create the IMMDeviceEnumerator interface. 209 ScopedComPtr<IMMDeviceEnumerator> device_enumerator = 210 CreateDeviceEnumerator(); 211 if (!device_enumerator) 212 return 0; 213 214 // Generate a collection of active (present and not disabled) audio endpoint 215 // devices for the specified data-flow direction. 216 // This method will succeed even if all devices are disabled. 217 ScopedComPtr<IMMDeviceCollection> collection; 218 HRESULT hr = device_enumerator->EnumAudioEndpoints(data_flow, 219 DEVICE_STATE_ACTIVE, 220 collection.Receive()); 221 if (FAILED(hr)) { 222 LOG(ERROR) << "IMMDeviceCollection::EnumAudioEndpoints: " << std::hex << hr; 223 return 0; 224 } 225 226 // Retrieve the number of active audio devices for the specified direction 227 UINT number_of_active_devices = 0; 228 collection->GetCount(&number_of_active_devices); 229 DVLOG(2) << ((data_flow == eCapture) ? "[in ] " : "[out] ") 230 << "number of devices: " << number_of_active_devices; 231 return static_cast<int>(number_of_active_devices); 232 } 233 234 ScopedComPtr<IMMDeviceEnumerator> CoreAudioUtil::CreateDeviceEnumerator() { 235 DCHECK(IsSupported()); 236 ScopedComPtr<IMMDeviceEnumerator> device_enumerator; 237 HRESULT hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), 238 NULL, CLSCTX_INPROC_SERVER); 239 if (hr == CO_E_NOTINITIALIZED) { 240 LOG(ERROR) << "CoCreateInstance fails with CO_E_NOTINITIALIZED"; 241 // We have seen crashes which indicates that this method can in fact 242 // fail with CO_E_NOTINITIALIZED in combination with certain 3rd party 243 // modules. Calling CoInitializeEx is an attempt to resolve the reported 244 // issues. See http://crbug.com/378465 for details. 245 hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); 246 if (SUCCEEDED(hr)) { 247 hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), 248 NULL, CLSCTX_INPROC_SERVER); 249 } 250 } 251 CHECK(SUCCEEDED(hr)); 252 return device_enumerator; 253 } 254 255 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDefaultDevice(EDataFlow data_flow, 256 ERole role) { 257 DCHECK(IsSupported()); 258 ScopedComPtr<IMMDevice> endpoint_device; 259 260 // Create the IMMDeviceEnumerator interface. 261 ScopedComPtr<IMMDeviceEnumerator> device_enumerator = 262 CreateDeviceEnumerator(); 263 if (!device_enumerator) 264 return endpoint_device; 265 266 // Retrieve the default audio endpoint for the specified data-flow 267 // direction and role. 268 HRESULT hr = device_enumerator->GetDefaultAudioEndpoint( 269 data_flow, role, endpoint_device.Receive()); 270 271 if (FAILED(hr)) { 272 DVLOG(1) << "IMMDeviceEnumerator::GetDefaultAudioEndpoint: " 273 << std::hex << hr; 274 return endpoint_device; 275 } 276 277 // Verify that the audio endpoint device is active, i.e., that the audio 278 // adapter that connects to the endpoint device is present and enabled. 279 DWORD state = DEVICE_STATE_DISABLED; 280 hr = endpoint_device->GetState(&state); 281 if (SUCCEEDED(hr)) { 282 if (!(state & DEVICE_STATE_ACTIVE)) { 283 DVLOG(1) << "Selected endpoint device is not active"; 284 endpoint_device.Release(); 285 } 286 } 287 return endpoint_device; 288 } 289 290 std::string CoreAudioUtil::GetDefaultOutputDeviceID() { 291 DCHECK(IsSupported()); 292 ScopedComPtr<IMMDevice> device(CreateDefaultDevice(eRender, eConsole)); 293 return device ? GetDeviceID(device) : std::string(); 294 } 295 296 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDevice( 297 const std::string& device_id) { 298 DCHECK(IsSupported()); 299 ScopedComPtr<IMMDevice> endpoint_device; 300 301 // Create the IMMDeviceEnumerator interface. 302 ScopedComPtr<IMMDeviceEnumerator> device_enumerator = 303 CreateDeviceEnumerator(); 304 if (!device_enumerator) 305 return endpoint_device; 306 307 // Retrieve an audio device specified by an endpoint device-identification 308 // string. 309 HRESULT hr = device_enumerator->GetDevice( 310 base::UTF8ToUTF16(device_id).c_str(), endpoint_device.Receive()); 311 DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: " 312 << std::hex << hr; 313 return endpoint_device; 314 } 315 316 HRESULT CoreAudioUtil::GetDeviceName(IMMDevice* device, AudioDeviceName* name) { 317 DCHECK(IsSupported()); 318 319 // Retrieve unique name of endpoint device. 320 // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}". 321 AudioDeviceName device_name; 322 device_name.unique_id = GetDeviceID(device); 323 if (device_name.unique_id.empty()) 324 return E_FAIL; 325 326 // Retrieve user-friendly name of endpoint device. 327 // Example: "Microphone (Realtek High Definition Audio)". 328 ScopedComPtr<IPropertyStore> properties; 329 HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.Receive()); 330 if (FAILED(hr)) 331 return hr; 332 base::win::ScopedPropVariant friendly_name; 333 hr = properties->GetValue(PKEY_Device_FriendlyName, friendly_name.Receive()); 334 if (FAILED(hr)) 335 return hr; 336 if (friendly_name.get().vt == VT_LPWSTR && friendly_name.get().pwszVal) { 337 base::WideToUTF8(friendly_name.get().pwszVal, 338 wcslen(friendly_name.get().pwszVal), 339 &device_name.device_name); 340 } 341 342 *name = device_name; 343 DVLOG(2) << "friendly name: " << device_name.device_name; 344 DVLOG(2) << "unique id : " << device_name.unique_id; 345 return hr; 346 } 347 348 std::string CoreAudioUtil::GetAudioControllerID(IMMDevice* device, 349 IMMDeviceEnumerator* enumerator) { 350 DCHECK(IsSupported()); 351 352 // Fetching the controller device id could be as simple as fetching the value 353 // of the "{B3F8FA53-0004-438E-9003-51A46E139BFC},2" property in the property 354 // store of the |device|, but that key isn't defined in any header and 355 // according to MS should not be relied upon. 356 // So, instead, we go deeper, look at the device topology and fetch the 357 // PKEY_Device_InstanceId of the associated physical audio device. 358 ScopedComPtr<IDeviceTopology> topology; 359 ScopedComPtr<IConnector> connector; 360 ScopedCoMem<WCHAR> filter_id; 361 if (FAILED(device->Activate(__uuidof(IDeviceTopology), CLSCTX_ALL, NULL, 362 topology.ReceiveVoid()) || 363 // For our purposes checking the first connected device should be enough 364 // and if there are cases where there are more than one device connected 365 // we're not sure how to handle that anyway. So we pass 0. 366 FAILED(topology->GetConnector(0, connector.Receive())) || 367 FAILED(connector->GetDeviceIdConnectedTo(&filter_id)))) { 368 DLOG(ERROR) << "Failed to get the device identifier of the audio device"; 369 return std::string(); 370 } 371 372 // Now look at the properties of the connected device node and fetch the 373 // instance id (PKEY_Device_InstanceId) of the device node that uniquely 374 // identifies the controller. 375 ScopedComPtr<IMMDevice> device_node; 376 ScopedComPtr<IPropertyStore> properties; 377 base::win::ScopedPropVariant instance_id; 378 if (FAILED(enumerator->GetDevice(filter_id, device_node.Receive())) || 379 FAILED(device_node->OpenPropertyStore(STGM_READ, properties.Receive())) || 380 FAILED(properties->GetValue(PKEY_Device_InstanceId, 381 instance_id.Receive())) || 382 instance_id.get().vt != VT_LPWSTR) { 383 DLOG(ERROR) << "Failed to get instance id of the audio device node"; 384 return std::string(); 385 } 386 387 std::string controller_id; 388 base::WideToUTF8(instance_id.get().pwszVal, 389 wcslen(instance_id.get().pwszVal), 390 &controller_id); 391 392 return controller_id; 393 } 394 395 std::string CoreAudioUtil::GetMatchingOutputDeviceID( 396 const std::string& input_device_id) { 397 ScopedComPtr<IMMDevice> input_device(CreateDevice(input_device_id)); 398 if (!input_device) 399 return std::string(); 400 401 // See if we can get id of the associated controller. 402 ScopedComPtr<IMMDeviceEnumerator> enumerator(CreateDeviceEnumerator()); 403 std::string controller_id(GetAudioControllerID(input_device, enumerator)); 404 if (controller_id.empty()) 405 return std::string(); 406 407 // Now enumerate the available (and active) output devices and see if any of 408 // them is associated with the same controller. 409 ScopedComPtr<IMMDeviceCollection> collection; 410 enumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, 411 collection.Receive()); 412 if (!collection) 413 return std::string(); 414 415 UINT count = 0; 416 collection->GetCount(&count); 417 ScopedComPtr<IMMDevice> output_device; 418 for (UINT i = 0; i < count; ++i) { 419 collection->Item(i, output_device.Receive()); 420 std::string output_controller_id(GetAudioControllerID( 421 output_device, enumerator)); 422 if (output_controller_id == controller_id) 423 break; 424 output_device = NULL; 425 } 426 427 return output_device ? GetDeviceID(output_device) : std::string(); 428 } 429 430 std::string CoreAudioUtil::GetFriendlyName(const std::string& device_id) { 431 DCHECK(IsSupported()); 432 ScopedComPtr<IMMDevice> audio_device = CreateDevice(device_id); 433 if (!audio_device) 434 return std::string(); 435 436 AudioDeviceName device_name; 437 HRESULT hr = GetDeviceName(audio_device, &device_name); 438 if (FAILED(hr)) 439 return std::string(); 440 441 return device_name.device_name; 442 } 443 444 bool CoreAudioUtil::DeviceIsDefault(EDataFlow flow, 445 ERole role, 446 const std::string& device_id) { 447 DCHECK(IsSupported()); 448 ScopedComPtr<IMMDevice> device = CreateDefaultDevice(flow, role); 449 if (!device) 450 return false; 451 452 std::string str_default(GetDeviceID(device)); 453 return device_id.compare(str_default) == 0; 454 } 455 456 EDataFlow CoreAudioUtil::GetDataFlow(IMMDevice* device) { 457 DCHECK(IsSupported()); 458 ScopedComPtr<IMMEndpoint> endpoint; 459 HRESULT hr = device->QueryInterface(endpoint.Receive()); 460 if (FAILED(hr)) { 461 DVLOG(1) << "IMMDevice::QueryInterface: " << std::hex << hr; 462 return eAll; 463 } 464 465 EDataFlow data_flow; 466 hr = endpoint->GetDataFlow(&data_flow); 467 if (FAILED(hr)) { 468 DVLOG(1) << "IMMEndpoint::GetDataFlow: " << std::hex << hr; 469 return eAll; 470 } 471 return data_flow; 472 } 473 474 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateClient( 475 IMMDevice* audio_device) { 476 DCHECK(IsSupported()); 477 478 // Creates and activates an IAudioClient COM object given the selected 479 // endpoint device. 480 ScopedComPtr<IAudioClient> audio_client; 481 HRESULT hr = audio_device->Activate(__uuidof(IAudioClient), 482 CLSCTX_INPROC_SERVER, 483 NULL, 484 audio_client.ReceiveVoid()); 485 DVLOG_IF(1, FAILED(hr)) << "IMMDevice::Activate: " << std::hex << hr; 486 return audio_client; 487 } 488 489 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateDefaultClient( 490 EDataFlow data_flow, ERole role) { 491 DCHECK(IsSupported()); 492 ScopedComPtr<IMMDevice> default_device(CreateDefaultDevice(data_flow, role)); 493 return (default_device ? CreateClient(default_device) : 494 ScopedComPtr<IAudioClient>()); 495 } 496 497 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateClient( 498 const std::string& device_id, EDataFlow data_flow, ERole role) { 499 if (device_id.empty()) 500 return CreateDefaultClient(data_flow, role); 501 502 ScopedComPtr<IMMDevice> device(CreateDevice(device_id)); 503 if (!device) 504 return ScopedComPtr<IAudioClient>(); 505 506 return CreateClient(device); 507 } 508 509 HRESULT CoreAudioUtil::GetSharedModeMixFormat( 510 IAudioClient* client, WAVEFORMATPCMEX* format) { 511 DCHECK(IsSupported()); 512 ScopedCoMem<WAVEFORMATPCMEX> format_pcmex; 513 HRESULT hr = client->GetMixFormat( 514 reinterpret_cast<WAVEFORMATEX**>(&format_pcmex)); 515 if (FAILED(hr)) 516 return hr; 517 518 size_t bytes = sizeof(WAVEFORMATEX) + format_pcmex->Format.cbSize; 519 DCHECK_EQ(bytes, sizeof(WAVEFORMATPCMEX)); 520 521 memcpy(format, format_pcmex, bytes); 522 DVLOG(2) << *format; 523 524 return hr; 525 } 526 527 bool CoreAudioUtil::IsFormatSupported(IAudioClient* client, 528 AUDCLNT_SHAREMODE share_mode, 529 const WAVEFORMATPCMEX* format) { 530 DCHECK(IsSupported()); 531 ScopedCoMem<WAVEFORMATEXTENSIBLE> closest_match; 532 HRESULT hr = client->IsFormatSupported( 533 share_mode, reinterpret_cast<const WAVEFORMATEX*>(format), 534 reinterpret_cast<WAVEFORMATEX**>(&closest_match)); 535 536 // This log can only be triggered for shared mode. 537 DLOG_IF(ERROR, hr == S_FALSE) << "Format is not supported " 538 << "but a closest match exists."; 539 // This log can be triggered both for shared and exclusive modes. 540 DLOG_IF(ERROR, hr == AUDCLNT_E_UNSUPPORTED_FORMAT) << "Unsupported format."; 541 if (hr == S_FALSE) { 542 DVLOG(2) << *closest_match; 543 } 544 545 return (hr == S_OK); 546 } 547 548 bool CoreAudioUtil::IsChannelLayoutSupported(const std::string& device_id, 549 EDataFlow data_flow, 550 ERole role, 551 ChannelLayout channel_layout) { 552 DCHECK(IsSupported()); 553 554 // First, get the preferred mixing format for shared mode streams. 555 556 ScopedComPtr<IAudioClient> client(CreateClient(device_id, data_flow, role)); 557 if (!client) 558 return false; 559 560 WAVEFORMATPCMEX format; 561 HRESULT hr = GetSharedModeMixFormat(client, &format); 562 if (FAILED(hr)) 563 return false; 564 565 // Next, check if it is possible to use an alternative format where the 566 // channel layout (and possibly number of channels) is modified. 567 568 // Convert generic channel layout into Windows-specific channel configuration. 569 ChannelConfig new_config = ChannelLayoutToChannelConfig(channel_layout); 570 if (new_config == KSAUDIO_SPEAKER_UNSUPPORTED) { 571 return false; 572 } 573 format.dwChannelMask = new_config; 574 575 // Modify the format if the new channel layout has changed the number of 576 // utilized channels. 577 const int channels = ChannelLayoutToChannelCount(channel_layout); 578 if (channels != format.Format.nChannels) { 579 format.Format.nChannels = channels; 580 format.Format.nBlockAlign = (format.Format.wBitsPerSample / 8) * channels; 581 format.Format.nAvgBytesPerSec = format.Format.nSamplesPerSec * 582 format.Format.nBlockAlign; 583 } 584 DVLOG(2) << format; 585 586 // Some devices can initialize a shared-mode stream with a format that is 587 // not identical to the mix format obtained from the GetMixFormat() method. 588 // However, chances of succeeding increases if we use the same number of 589 // channels and the same sample rate as the mix format. I.e, this call will 590 // return true only in those cases where the audio engine is able to support 591 // an even wider range of shared-mode formats where the installation package 592 // for the audio device includes a local effects (LFX) audio processing 593 // object (APO) that can handle format conversions. 594 return CoreAudioUtil::IsFormatSupported(client, AUDCLNT_SHAREMODE_SHARED, 595 &format); 596 } 597 598 HRESULT CoreAudioUtil::GetDevicePeriod(IAudioClient* client, 599 AUDCLNT_SHAREMODE share_mode, 600 REFERENCE_TIME* device_period) { 601 DCHECK(IsSupported()); 602 603 // Get the period of the engine thread. 604 REFERENCE_TIME default_period = 0; 605 REFERENCE_TIME minimum_period = 0; 606 HRESULT hr = client->GetDevicePeriod(&default_period, &minimum_period); 607 if (FAILED(hr)) 608 return hr; 609 610 *device_period = (share_mode == AUDCLNT_SHAREMODE_SHARED) ? default_period : 611 minimum_period; 612 DVLOG(2) << "device_period: " 613 << RefererenceTimeToTimeDelta(*device_period).InMillisecondsF() 614 << " [ms]"; 615 return hr; 616 } 617 618 HRESULT CoreAudioUtil::GetPreferredAudioParameters( 619 IAudioClient* client, AudioParameters* params) { 620 DCHECK(IsSupported()); 621 WAVEFORMATPCMEX mix_format; 622 HRESULT hr = GetSharedModeMixFormat(client, &mix_format); 623 if (FAILED(hr)) 624 return hr; 625 626 REFERENCE_TIME default_period = 0; 627 hr = GetDevicePeriod(client, AUDCLNT_SHAREMODE_SHARED, &default_period); 628 if (FAILED(hr)) 629 return hr; 630 631 // Get the integer mask which corresponds to the channel layout the 632 // audio engine uses for its internal processing/mixing of shared-mode 633 // streams. This mask indicates which channels are present in the multi- 634 // channel stream. The least significant bit corresponds with the Front Left 635 // speaker, the next least significant bit corresponds to the Front Right 636 // speaker, and so on, continuing in the order defined in KsMedia.h. 637 // See http://msdn.microsoft.com/en-us/library/windows/hardware/ff537083.aspx 638 // for more details. 639 ChannelConfig channel_config = mix_format.dwChannelMask; 640 641 // Convert Microsoft's channel configuration to genric ChannelLayout. 642 ChannelLayout channel_layout = ChannelConfigToChannelLayout(channel_config); 643 644 // Some devices don't appear to set a valid channel layout, so guess based on 645 // the number of channels. See http://crbug.com/311906. 646 if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED) { 647 VLOG(1) << "Unsupported channel config: " 648 << std::hex << channel_config 649 << ". Guessing layout by channel count: " 650 << std::dec << mix_format.Format.nChannels; 651 channel_layout = GuessChannelLayout(mix_format.Format.nChannels); 652 } 653 654 // Preferred sample rate. 655 int sample_rate = mix_format.Format.nSamplesPerSec; 656 657 // TODO(henrika): possibly use format.Format.wBitsPerSample here instead. 658 // We use a hard-coded value of 16 bits per sample today even if most audio 659 // engines does the actual mixing in 32 bits per sample. 660 int bits_per_sample = 16; 661 662 // We are using the native device period to derive the smallest possible 663 // buffer size in shared mode. Note that the actual endpoint buffer will be 664 // larger than this size but it will be possible to fill it up in two calls. 665 // TODO(henrika): ensure that this scheme works for capturing as well. 666 int frames_per_buffer = static_cast<int>(sample_rate * 667 RefererenceTimeToTimeDelta(default_period).InSecondsF() + 0.5); 668 669 DVLOG(1) << "channel_layout : " << channel_layout; 670 DVLOG(1) << "sample_rate : " << sample_rate; 671 DVLOG(1) << "bits_per_sample : " << bits_per_sample; 672 DVLOG(1) << "frames_per_buffer: " << frames_per_buffer; 673 674 AudioParameters audio_params(AudioParameters::AUDIO_PCM_LOW_LATENCY, 675 channel_layout, 676 sample_rate, 677 bits_per_sample, 678 frames_per_buffer); 679 680 *params = audio_params; 681 return hr; 682 } 683 684 HRESULT CoreAudioUtil::GetPreferredAudioParameters( 685 EDataFlow data_flow, ERole role, AudioParameters* params) { 686 DCHECK(IsSupported()); 687 ScopedComPtr<IAudioClient> client(CreateDefaultClient(data_flow, role)); 688 if (!client) { 689 // Map NULL-pointer to new error code which can be different from the 690 // actual error code. The exact value is not important here. 691 return AUDCLNT_E_ENDPOINT_CREATE_FAILED; 692 } 693 694 HRESULT hr = GetPreferredAudioParameters(client, params); 695 if (FAILED(hr)) 696 return hr; 697 698 if (role == eCommunications) { 699 // Raise the 'DUCKING' flag for default communication devices. 700 *params = AudioParameters(params->format(), params->channel_layout(), 701 params->channels(), params->sample_rate(), params->bits_per_sample(), 702 params->frames_per_buffer(), 703 params->effects() | AudioParameters::DUCKING); 704 } 705 706 return hr; 707 } 708 709 HRESULT CoreAudioUtil::GetPreferredAudioParameters( 710 const std::string& device_id, AudioParameters* params) { 711 DCHECK(IsSupported()); 712 ScopedComPtr<IMMDevice> device(CreateDevice(device_id)); 713 if (!device) { 714 // Map NULL-pointer to new error code which can be different from the 715 // actual error code. The exact value is not important here. 716 return AUDCLNT_E_DEVICE_INVALIDATED; 717 } 718 719 ScopedComPtr<IAudioClient> client(CreateClient(device)); 720 if (!client) { 721 // Map NULL-pointer to new error code which can be different from the 722 // actual error code. The exact value is not important here. 723 return AUDCLNT_E_ENDPOINT_CREATE_FAILED; 724 } 725 return GetPreferredAudioParameters(client, params); 726 } 727 728 ChannelConfig CoreAudioUtil::GetChannelConfig(const std::string& device_id, 729 EDataFlow data_flow) { 730 ScopedComPtr<IAudioClient> client( 731 CreateClient(device_id, data_flow, eConsole)); 732 733 WAVEFORMATPCMEX format = {0}; 734 if (!client || FAILED(GetSharedModeMixFormat(client, &format))) 735 return 0; 736 737 return static_cast<ChannelConfig>(format.dwChannelMask); 738 } 739 740 HRESULT CoreAudioUtil::SharedModeInitialize( 741 IAudioClient* client, const WAVEFORMATPCMEX* format, HANDLE event_handle, 742 uint32* endpoint_buffer_size, const GUID* session_guid) { 743 DCHECK(IsSupported()); 744 745 // Use default flags (i.e, dont set AUDCLNT_STREAMFLAGS_NOPERSIST) to 746 // ensure that the volume level and muting state for a rendering session 747 // are persistent across system restarts. The volume level and muting 748 // state for a capture session are never persistent. 749 DWORD stream_flags = 0; 750 751 // Enable event-driven streaming if a valid event handle is provided. 752 // After the stream starts, the audio engine will signal the event handle 753 // to notify the client each time a buffer becomes ready to process. 754 // Event-driven buffering is supported for both rendering and capturing. 755 // Both shared-mode and exclusive-mode streams can use event-driven buffering. 756 bool use_event = (event_handle != NULL && 757 event_handle != INVALID_HANDLE_VALUE); 758 if (use_event) 759 stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK; 760 DVLOG(2) << "stream_flags: 0x" << std::hex << stream_flags; 761 762 // Initialize the shared mode client for minimal delay. 763 HRESULT hr = client->Initialize(AUDCLNT_SHAREMODE_SHARED, 764 stream_flags, 765 0, 766 0, 767 reinterpret_cast<const WAVEFORMATEX*>(format), 768 session_guid); 769 if (FAILED(hr)) { 770 DVLOG(1) << "IAudioClient::Initialize: " << std::hex << hr; 771 return hr; 772 } 773 774 if (use_event) { 775 hr = client->SetEventHandle(event_handle); 776 if (FAILED(hr)) { 777 DVLOG(1) << "IAudioClient::SetEventHandle: " << std::hex << hr; 778 return hr; 779 } 780 } 781 782 UINT32 buffer_size_in_frames = 0; 783 hr = client->GetBufferSize(&buffer_size_in_frames); 784 if (FAILED(hr)) { 785 DVLOG(1) << "IAudioClient::GetBufferSize: " << std::hex << hr; 786 return hr; 787 } 788 789 *endpoint_buffer_size = buffer_size_in_frames; 790 DVLOG(2) << "endpoint buffer size: " << buffer_size_in_frames; 791 792 // TODO(henrika): utilize when delay measurements are added. 793 REFERENCE_TIME latency = 0; 794 hr = client->GetStreamLatency(&latency); 795 DVLOG(2) << "stream latency: " 796 << RefererenceTimeToTimeDelta(latency).InMillisecondsF() << " [ms]"; 797 return hr; 798 } 799 800 ScopedComPtr<IAudioRenderClient> CoreAudioUtil::CreateRenderClient( 801 IAudioClient* client) { 802 DCHECK(IsSupported()); 803 804 // Get access to the IAudioRenderClient interface. This interface 805 // enables us to write output data to a rendering endpoint buffer. 806 ScopedComPtr<IAudioRenderClient> audio_render_client; 807 HRESULT hr = client->GetService(__uuidof(IAudioRenderClient), 808 audio_render_client.ReceiveVoid()); 809 if (FAILED(hr)) { 810 DVLOG(1) << "IAudioClient::GetService: " << std::hex << hr; 811 return ScopedComPtr<IAudioRenderClient>(); 812 } 813 return audio_render_client; 814 } 815 816 ScopedComPtr<IAudioCaptureClient> CoreAudioUtil::CreateCaptureClient( 817 IAudioClient* client) { 818 DCHECK(IsSupported()); 819 820 // Get access to the IAudioCaptureClient interface. This interface 821 // enables us to read input data from a capturing endpoint buffer. 822 ScopedComPtr<IAudioCaptureClient> audio_capture_client; 823 HRESULT hr = client->GetService(__uuidof(IAudioCaptureClient), 824 audio_capture_client.ReceiveVoid()); 825 if (FAILED(hr)) { 826 DVLOG(1) << "IAudioClient::GetService: " << std::hex << hr; 827 return ScopedComPtr<IAudioCaptureClient>(); 828 } 829 return audio_capture_client; 830 } 831 832 bool CoreAudioUtil::FillRenderEndpointBufferWithSilence( 833 IAudioClient* client, IAudioRenderClient* render_client) { 834 DCHECK(IsSupported()); 835 836 UINT32 endpoint_buffer_size = 0; 837 if (FAILED(client->GetBufferSize(&endpoint_buffer_size))) 838 return false; 839 840 UINT32 num_queued_frames = 0; 841 if (FAILED(client->GetCurrentPadding(&num_queued_frames))) 842 return false; 843 844 BYTE* data = NULL; 845 int num_frames_to_fill = endpoint_buffer_size - num_queued_frames; 846 if (FAILED(render_client->GetBuffer(num_frames_to_fill, &data))) 847 return false; 848 849 // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to 850 // explicitly write silence data to the rendering buffer. 851 DVLOG(2) << "filling up " << num_frames_to_fill << " frames with silence"; 852 return SUCCEEDED(render_client->ReleaseBuffer(num_frames_to_fill, 853 AUDCLNT_BUFFERFLAGS_SILENT)); 854 } 855 856 } // namespace media 857
