Include default communication devices in audio device enumerations. This removes heuristic that pic…

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 <devicetopology.h>
 #include <functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
@@ skipping 405 matching lines @@
   std::string controller_id;
   base::WideToUTF8(instance_id.get().pwszVal,
                    wcslen(instance_id.get().pwszVal),
                    &controller_id);
 
   return controller_id;
 }
 
 std::string CoreAudioUtil::GetMatchingOutputDeviceID(
     const std::string& input_device_id) {
-  ScopedComPtr<IMMDevice> input_device(CreateDevice(input_device_id));
+  // Special handling for the default communications device.
+  // We always treat the configured communications devices, as a pair.
+  // If we didn't do that and the user has e.g. configured a mic of a headset
+  // as the default comms input device and a different device (not the speakers
+  // of the headset) as the default comms output device, then we would otherwise
+  // here pick the headset as the matched output device.  That's technically
+  // correct, but the user experience would be that any audio played out to
+  // the matched device, would get ducked since it's not the default comms
+  // device.  So here, we go with the user's configuration.
+  if (input_device_id == AudioManagerBase::kCommunicationsDeviceId)
+    return AudioManagerBase::kCommunicationsDeviceId;
+
+  ScopedComPtr<IMMDevice> input_device;
+  if (input_device_id.empty() ||
+      input_device_id == AudioManagerBase::kDefaultDeviceId) {
+    input_device = CreateDefaultDevice(eCapture, eConsole);
+  } else {
+    input_device = CreateDevice(input_device_id);
+  }
+
   if (!input_device.get())
     return std::string();
 
   // See if we can get id of the associated controller.
   ScopedComPtr<IMMDeviceEnumerator> enumerator(CreateDeviceEnumerator());
   std::string controller_id(
       GetAudioControllerID(input_device.get(), enumerator.get()));
   if (controller_id.empty())
     return std::string();
 
@@ skipping 279 matching lines @@
                                                    AudioParameters* params) {
   DCHECK(IsSupported());
 
   ScopedComPtr<IMMDevice> device;
   if (device_id == AudioManagerBase::kDefaultDeviceId) {
     device = CoreAudioUtil::CreateDefaultDevice(
         is_output_device ? eRender : eCapture, eConsole);
   } else if (device_id == AudioManagerBase::kLoopbackInputDeviceId) {
     DCHECK(!is_output_device);
     device = CoreAudioUtil::CreateDefaultDevice(eRender, eConsole);
+  } else if (device_id == AudioManagerBase::kCommunicationsDeviceId) {
+    device = CoreAudioUtil::CreateDefaultDevice(
+        is_output_device ? eRender : eCapture, eCommunications);
   } else {
     device = CreateDevice(device_id);
   }
 
   if (!device.get()) {
     // Map NULL-pointer to new error code which can be different from the
     // actual error code. The exact value is not important here.
     return AUDCLNT_E_DEVICE_INVALIDATED;
   }
 
@@ skipping 12 matching lines @@
   DCHECK(!is_output_device);
 
   // TODO(dalecurtis): Old code rewrote != 1 channels to stereo, do we still
   // need to do the same thing?
   if (params->channels() != 1) {
     params->Reset(params->format(), CHANNEL_LAYOUT_STEREO, 2,
                   params->sample_rate(), params->bits_per_sample(),
                   params->frames_per_buffer());
   }
 
-  ScopedComPtr<IMMDevice> communications_device(
-      CreateDefaultDevice(eCapture, eCommunications));
-  if (communications_device &&
-      GetDeviceID(communications_device.get()) == GetDeviceID(device.get())) {
-    // Raise the 'DUCKING' flag for default communication devices.
-    *params =
-        AudioParameters(params->format(), params->channel_layout(),
-                        params->channels(), params->sample_rate(),
-                        params->bits_per_sample(), params->frames_per_buffer(),
-                        params->effects() | AudioParameters::DUCKING);
-  }
-
   return hr;
 }
 
 ChannelConfig CoreAudioUtil::GetChannelConfig(const std::string& device_id,
                                               EDataFlow data_flow) {
   ScopedComPtr<IAudioClient> client(
       CreateClient(device_id, data_flow, eConsole));
 
   WAVEFORMATPCMEX format = {};
   if (!client.get() || FAILED(GetSharedModeMixFormat(client.get(), &format)))
@@ skipping 112 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