src/media/audio/win/core_audio_util_win.cc

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