Disable low latency audio under remote desktop sessions.

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 118 matching lines @@
 
 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);
 }
 
-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)))
     base::WideToUTF8(device_id_com, wcslen(device_id_com), &device_id);
   return device_id;
 }
 
-bool CoreAudioUtil::IsSupported() {
+static HRESULT GetDeviceFriendlyNameInternal(IMMDevice* device,
+                                             std::string* friendly_name) {
+  // Retrieve user-friendly name of endpoint device.
+  // Example: "Microphone (Realtek High Definition Audio)".
+  ScopedComPtr<IPropertyStore> properties;
+  HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.Receive());
+  if (FAILED(hr))
+    return hr;
+
+  base::win::ScopedPropVariant friendly_name_pv;
+  hr = properties->GetValue(PKEY_Device_FriendlyName,
+                            friendly_name_pv.Receive());
+  if (FAILED(hr))
+    return hr;
+
+  if (friendly_name_pv.get().vt == VT_LPWSTR &&
+      friendly_name_pv.get().pwszVal) {
+    base::WideToUTF8(friendly_name_pv.get().pwszVal,
+                     wcslen(friendly_name_pv.get().pwszVal), friendly_name);
+  }
+
+  return hr;
+}
+
+static ScopedComPtr<IMMDeviceEnumerator> CreateDeviceEnumeratorInternal() {
+  ScopedComPtr<IMMDeviceEnumerator> device_enumerator;
+  HRESULT hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
+                                                NULL, CLSCTX_INPROC_SERVER);
+  if (hr == CO_E_NOTINITIALIZED) {
+    LOG(ERROR) << "CoCreateInstance fails with CO_E_NOTINITIALIZED";
+    // We have seen crashes which indicates that this method can in fact
+    // fail with CO_E_NOTINITIALIZED in combination with certain 3rd party
+    // modules. Calling CoInitializeEx is an attempt to resolve the reported
+    // issues. See http://crbug.com/378465 for details.
+    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);

[henrika (OOO until Aug 14), 2015/04/07 07:41:08]

I hope Tommi can comment on this part.

[DaleCurtis, 2015/04/07 22:24:54]

Can you elaborate on your question? I think it was an error that we weren't
doing this in the CanCreateDeviceEnumerator() code previously.

[henrika (OOO until Aug 14), 2015/04/08 06:57:36]

I think you are correct but maybe Tommi has a second opinion. He knows this area
very well. That's all I meant.

+    if (SUCCEEDED(hr)) {
+      hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
+                                            NULL, CLSCTX_INPROC_SERVER);
+    }
+  }
+  return device_enumerator;
+}
+
+static bool IsRemoteSession() {
+  return !!GetSystemMetrics(SM_REMOTESESSION);
+}
+
+static bool IsRemoteDeviceInternal(IMMDevice* device) {
+  DCHECK(IsRemoteSession());
+
+  std::string device_name;
+  HRESULT hr = GetDeviceFriendlyNameInternal(device, &device_name);
+
+  // This method should only be called if IsRemoteSession() is true, so assume
+  // we have a remote audio device if we can't tell.
+  if (FAILED(hr))
+    return true;
+
+  return device_name == "Remote Audio";

[henrika (OOO until Aug 14), 2015/04/07 07:41:08]

Any reference to how we know that this is always the case?
Skip case sensitive?

[DaleCurtis, 2015/04/07 22:24:54]

Couldn't find any reference. I have no idea if "Remote Audio" is the same name
used with a french / japanese / etc installation. It'd be better if we could
compare on device id, but I don't know if those are the same for all windows
installations.

[henrika (OOO until Aug 14), 2015/04/08 06:57:36]

Acknowledged.

+}
+
+static bool IsSupportedInternal() {
   // It is possible to force usage of WaveXxx APIs by using a command line flag.
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kForceWaveAudio)) {
     DVLOG(1) << "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,
   // Windows XP, Windows Millennium Edition, Windows 2000, and Windows 98.
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
 
   // The audio core APIs are implemented in the Mmdevapi.dll and Audioses.dll
   // system components.
   // Dependency Walker shows that it is enough to verify possibility to load
   // the Audioses DLL since it depends on Mmdevapi.dll.
   // See http://crbug.com/166397 why this extra step is required to guarantee
   // Core Audio support.
-  static bool g_audioses_dll_available = LoadAudiosesDll();
-  if (!g_audioses_dll_available)
+  if (!LoadAudiosesDll())
     return false;
 
   // Being able to load the Audioses.dll does not seem to be sufficient for
   // all devices to guarantee Core Audio support. To be 100%, we also verify
   // that it is possible to a create the IMMDeviceEnumerator interface. If this
   // works as well we should be home free.
-  static bool g_can_create_device_enumerator = CanCreateDeviceEnumerator();
-  LOG_IF(ERROR, !g_can_create_device_enumerator)
-      << "Failed to create Core Audio device enumerator on thread with ID "
-      << GetCurrentThreadId();
-  return g_can_create_device_enumerator;
+  ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
+      CreateDeviceEnumeratorInternal();
+  if (!device_enumerator) {
+    LOG(ERROR)
+        << "Failed to create Core Audio device enumerator on thread with ID "
+        << GetCurrentThreadId();
+    return false;
+  }
+
+  // Don't use CoreAudio when a remote desktop session with remote audio is
+  // present; several users report only WaveAudio working for them and crash
+  // reports show hangs when calling into the OS for CoreAudio API calls. See
+  // http://crbug.com/422522 and http://crbug.com/180591.
+  //
+  // Note: There's another check in WASAPIAudioOutputStream::Open() for the case
+  // where a remote session is created after Chrome has been started.  Graceful
+  // fallback to WaveOut will occur in this case via AudioOutputResampler.
+  if (!IsRemoteSession())
+    return true;
+
+  ScopedComPtr<IMMDevice> device;
+  HRESULT hr = device_enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
+                                                          device.Receive());
+
+  // Assume remote audio playback if we can't tell.
+  if (FAILED(hr))

[henrika (OOO until Aug 14), 2015/04/07 07:41:08]

Do we need this check? Is it not included in IsRemoteDeviceInternal?

[DaleCurtis, 2015/04/07 22:24:54]

Seems GetDefaultAudioEndpoint could still fail? that check below doesn't see if
device is null.

[henrika (OOO until Aug 14), 2015/04/08 06:57:36]

Acknowledged.

+    return false;
+
+  return !IsRemoteDeviceInternal(device.get());
+}
+
+bool CoreAudioUtil::IsSupported() {
+  static bool g_is_supported = IsSupportedInternal();
+  return g_is_supported;
 }
 
 base::TimeDelta CoreAudioUtil::RefererenceTimeToTimeDelta(REFERENCE_TIME time) {
   // Each unit of reference time is 100 nanoseconds <=> 0.1 microsecond.
   return base::TimeDelta::FromMicroseconds(0.1 * time + 0.5);
 }
 
 AUDCLNT_SHAREMODE CoreAudioUtil::GetShareMode() {
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio))
@@ skipping 24 matching lines @@
   // Retrieve the number of active audio devices for the specified direction
   UINT number_of_active_devices = 0;
   collection->GetCount(&number_of_active_devices);
   DVLOG(2) << ((data_flow == eCapture) ? "[in ] " : "[out] ")
            << "number of devices: " << number_of_active_devices;
   return static_cast<int>(number_of_active_devices);
 }
 
 ScopedComPtr<IMMDeviceEnumerator> CoreAudioUtil::CreateDeviceEnumerator() {
   DCHECK(IsSupported());
-  ScopedComPtr<IMMDeviceEnumerator> device_enumerator;
-  HRESULT hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
-                                                NULL, CLSCTX_INPROC_SERVER);
-  if (hr == CO_E_NOTINITIALIZED) {
-    LOG(ERROR) << "CoCreateInstance fails with CO_E_NOTINITIALIZED";
-    // We have seen crashes which indicates that this method can in fact
-    // fail with CO_E_NOTINITIALIZED in combination with certain 3rd party
-    // modules. Calling CoInitializeEx is an attempt to resolve the reported
-    // issues. See http://crbug.com/378465 for details.
-    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
-    if (SUCCEEDED(hr)) {
-      hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
-                                            NULL, CLSCTX_INPROC_SERVER);
-    }
-  }
-  CHECK(SUCCEEDED(hr));
+  ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
+      CreateDeviceEnumeratorInternal();
+  CHECK(device_enumerator);
   return device_enumerator;
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDefaultDevice(EDataFlow data_flow,
                                                            ERole role) {
   DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
@@ skipping 54 matching lines @@
 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;
   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;
-  HRESULT hr = device->OpenPropertyStore(STGM_READ, properties.Receive());
+  HRESULT hr = GetDeviceFriendlyNameInternal(device, &device_name.device_name);
   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) {
-    base::WideToUTF8(friendly_name.get().pwszVal,
-                     wcslen(friendly_name.get().pwszVal),
-                     &device_name.device_name);
-  }
 
   *name = device_name;
   DVLOG(2) << "friendly name: " << device_name.device_name;
   DVLOG(2) << "unique id    : " << device_name.unique_id;
   return hr;
 }
 
 std::string CoreAudioUtil::GetAudioControllerID(IMMDevice* device,
     IMMDeviceEnumerator* enumerator) {
   DCHECK(IsSupported());
@@ skipping 496 matching lines @@
   if (FAILED(render_client->GetBuffer(num_frames_to_fill, &data)))
     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));
 }
 
+bool CoreAudioUtil::IsRemoteOutputDevice(const std::string& device_id) {
+  DCHECK(IsSupported());
+  if (!IsRemoteSession())
+    return false;
+  ScopedComPtr<IMMDevice> device(device_id.empty()
+                                     ? CreateDefaultDevice(eRender, eConsole)
+                                     : CreateDevice(device_id));
+  // Assume remote audio if we can't tell.
+  return device ? IsRemoteDeviceInternal(device.get()) : true;
+}
+
 }  // namespace media