Add GetOutputStreamParameters, GetAssociatedOutputDeviceID to AudioManager.

media/audio/win/core_audio_util_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/win/core_audio_util_win.h"
 
 #include <audioclient.h>
 #include <devicetopology.h>
 #include <functiondiscoverykeys_devpkey.h>
 
@@ skipping 105 matching lines @@
      << ", nSamplesPerSec: " << format.Format.nSamplesPerSec
      << ", nAvgBytesPerSec: " << format.Format.nAvgBytesPerSec
      << ", nBlockAlign: " << format.Format.nBlockAlign
      << ", wBitsPerSample: " << format.Format.wBitsPerSample
      << ", cbSize: " << format.Format.cbSize
      << ", wValidBitsPerSample: " << format.Samples.wValidBitsPerSample
      << ", dwChannelMask: 0x" << std::hex << format.dwChannelMask;
   return os;
 }
 
-bool LoadAudiosesDll() {
+static bool LoadAudiosesDll() {
   static const wchar_t* const kAudiosesDLL =
       L"%WINDIR%\\system32\\audioses.dll";
 
   wchar_t path[MAX_PATH] = {0};
   ExpandEnvironmentStringsW(kAudiosesDLL, path, arraysize(path));
   return (LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH) != NULL);
 }
 
-bool CanCreateDeviceEnumerator() {
+static bool CanCreateDeviceEnumerator() {
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator;
   HRESULT hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
                                                 NULL, CLSCTX_INPROC_SERVER);
 
   // If we hit CO_E_NOTINITIALIZED, CoInitialize has not been called and it
   // must be called at least once for each thread that uses the COM library.
   CHECK_NE(hr, CO_E_NOTINITIALIZED);
 
   return SUCCEEDED(hr);
 }
 
+static std::string GetDeviceID(IMMDevice* device) {
+  ScopedCoMem<WCHAR> device_id_com;
+  std::string device_id;
+  if (SUCCEEDED(device->GetId(&device_id_com)))
+    WideToUTF8(device_id_com, wcslen(device_id_com), &device_id);
+  return device_id;
+}
+
 bool CoreAudioUtil::IsSupported() {
   // It is possible to force usage of WaveXxx APIs by using a command line flag.
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kForceWaveAudio)) {
     LOG(WARNING) << "Forcing usage of Windows WaveXxx APIs";
     return false;
   }
 
   // Microsoft does not plan to make the Core Audio APIs available for use
   // with earlier versions of Windows, including Microsoft Windows Server 2003,
@@ skipping 99 matching lines @@
   hr = endpoint_device->GetState(&state);
   if (SUCCEEDED(hr)) {
     if (!(state & DEVICE_STATE_ACTIVE)) {
       DVLOG(1) << "Selected endpoint device is not active";
       endpoint_device.Release();
     }
   }
   return endpoint_device;
 }
 
+std::string CoreAudioUtil::GetDefaultOutputDeviceID() {
+  DCHECK(IsSupported());
+  ScopedComPtr<IMMDevice> device(CreateDefaultDevice(eRender, eConsole));
+  return device ? GetDeviceID(device) : std::string();
+}
+
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDevice(
     const std::string& device_id) {
   DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator)
     return endpoint_device;
 
   // Retrieve an audio device specified by an endpoint device-identification
   // string.
   HRESULT hr = device_enumerator->GetDevice(UTF8ToUTF16(device_id).c_str(),
                                             endpoint_device.Receive());
   DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: "
                           << std::hex << hr;
   return endpoint_device;
 }
 
 HRESULT CoreAudioUtil::GetDeviceName(IMMDevice* device, AudioDeviceName* name) {
   DCHECK(IsSupported());
 
   // Retrieve unique name of endpoint device.
   // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}".
   AudioDeviceName device_name;
-  ScopedCoMem<WCHAR> endpoint_device_id;
-  HRESULT hr = device->GetId(&endpoint_device_id);
-  if (FAILED(hr))
-    return hr;
-  WideToUTF8(endpoint_device_id, wcslen(endpoint_device_id),
-             &device_name.unique_id);
+  device_name.unique_id = GetDeviceID(device);
+  if (device_name.unique_id.empty())
+    return E_FAIL;
 
   // Retrieve user-friendly name of endpoint device.
   // Example: "Microphone (Realtek High Definition Audio)".
   ScopedComPtr<IPropertyStore> properties;
-  hr = device->OpenPropertyStore(STGM_READ, properties.Receive());
+  HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.Receive());
   if (FAILED(hr))
     return hr;
   base::win::ScopedPropVariant friendly_name;
   hr = properties->GetValue(PKEY_Device_FriendlyName, friendly_name.Receive());
   if (FAILED(hr))
     return hr;
   if (friendly_name.get().vt == VT_LPWSTR && friendly_name.get().pwszVal) {
     WideToUTF8(friendly_name.get().pwszVal,
                wcslen(friendly_name.get().pwszVal),
                &device_name.device_name);
@@ skipping 77 matching lines @@
   ScopedComPtr<IMMDevice> output_device;
   for (UINT i = 0; i < count; ++i) {
     collection->Item(i, output_device.Receive());
     std::string output_controller_id(CoreAudioUtil::GetAudioControllerID(
         output_device, enumerator));
     if (output_controller_id == controller_id)
       break;
     output_device = NULL;
   }
 
-  std::string id;
-  if (output_device) {
-    ScopedCoMem<WCHAR> wide_id;
-    output_device->GetId(&wide_id);
-    WideToUTF8(wide_id, wcslen(wide_id), &id);
-  }
-
-  return id;
+  return output_device ? GetDeviceID(output_device) : std::string();
 }
 
 std::string CoreAudioUtil::GetFriendlyName(const std::string& device_id) {
   DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> audio_device = CreateDevice(device_id);
   if (!audio_device)
     return std::string();
 
   AudioDeviceName device_name;
   HRESULT hr = GetDeviceName(audio_device, &device_name);
   if (FAILED(hr))
     return std::string();
 
   return device_name.device_name;
 }
 
 bool CoreAudioUtil::DeviceIsDefault(EDataFlow flow,
                                     ERole role,
                                     const std::string& device_id) {
   DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> device = CreateDefaultDevice(flow, role);
   if (!device)
     return false;
 
-  ScopedCoMem<WCHAR> default_device_id;
-  HRESULT hr = device->GetId(&default_device_id);
-  if (FAILED(hr))
-    return false;
-
-  std::string str_default;
-  WideToUTF8(default_device_id, wcslen(default_device_id), &str_default);
-  if (device_id.compare(str_default) != 0)
-    return false;
-  return true;
+  std::string str_default(GetDeviceID(device));
+  return device_id.compare(str_default) == 0;
 }
 
 EDataFlow CoreAudioUtil::GetDataFlow(IMMDevice* device) {
   DCHECK(IsSupported());
   ScopedComPtr<IMMEndpoint> endpoint;
   HRESULT hr = device->QueryInterface(endpoint.Receive());
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDevice::QueryInterface: " << std::hex << hr;
     return eAll;
   }
@@ skipping 347 matching lines @@
     return false;
 
   // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to
   // explicitly write silence data to the rendering buffer.
   DVLOG(2) << "filling up " << num_frames_to_fill << " frames with silence";
   return SUCCEEDED(render_client->ReleaseBuffer(num_frames_to_fill,
                                                 AUDCLNT_BUFFERFLAGS_SILENT));
 }
 
 }  // namespace media