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

media/audio/win/audio_low_latency_input_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/audio_low_latency_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/audio/win/audio_manager_win.h"
@@ skipping 10 matching lines @@
                                                const AudioParameters& params,
                                                const std::string& device_id)
     : manager_(manager),
       capture_thread_(NULL),
       opened_(false),
       started_(false),
       frame_size_(0),
       packet_size_frames_(0),
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
-      effects_(params.effects()),
       device_id_(device_id),
       perf_count_to_100ns_units_(0.0),
       ms_to_frame_count_(0.0),
       sink_(NULL),
       audio_bus_(media::AudioBus::Create(params)) {
   DCHECK(manager_);
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the Avrt.dll";
@@ skipping 384 matching lines @@
 
   ScopedComPtr<IMMDeviceEnumerator> enumerator;
   HRESULT hr = enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
                                          NULL, CLSCTX_INPROC_SERVER);
   if (FAILED(hr))
     return hr;
 
   // Retrieve the IMMDevice by using the specified role or the specified
   // unique endpoint device-identification string.
 
-  if (effects_ & AudioParameters::DUCKING) {
-    // Ducking has been requested and it is only supported for the default
-    // communication device.  So, let's open up the communication device and
-    // see if the ID of that device matches the requested ID.
-    // We consider a kDefaultDeviceId as well as an explicit device id match,
-    // to be valid matches.
+  if (device_id_ == AudioManagerBase::kDefaultDeviceId) {
+    // Retrieve the default capture audio endpoint for the specified role.
+    // Note that, in Windows Vista, the MMDevice API supports device roles
+    // but the system-supplied user interface programs do not.
+    hr = enumerator->GetDefaultAudioEndpoint(eCapture, eConsole,
+                                             endpoint_device_.Receive());
+  } else if (device_id_ == AudioManagerBase::kCommunicationsDeviceId) {
     hr = enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
                                              endpoint_device_.Receive());
-    if (endpoint_device_.get() &&
-        device_id_ != AudioManagerBase::kDefaultDeviceId) {
-      base::win::ScopedCoMem<WCHAR> communications_id;
-      endpoint_device_->GetId(&communications_id);
-      if (device_id_ !=
-          base::WideToUTF8(static_cast<WCHAR*>(communications_id))) {
-        DLOG(WARNING) << "Ducking has been requested for a non-default device."
-                         "Not supported.";
-        // We can't honor the requested effect flag, so turn it off and
-        // continue.  We'll check this flag later to see if we've actually
-        // opened up the communications device, so it's important that it
-        // reflects the active state.
-        effects_ &= ~AudioParameters::DUCKING;
-        endpoint_device_.Release();  // Fall back on code below.
-      }
-    }
-  }
-
-  if (!endpoint_device_.get()) {
-    if (device_id_ == AudioManagerBase::kDefaultDeviceId) {
-      // Retrieve the default capture audio endpoint for the specified role.
-      // Note that, in Windows Vista, the MMDevice API supports device roles
-      // but the system-supplied user interface programs do not.
-      hr = enumerator->GetDefaultAudioEndpoint(eCapture, eConsole,
-                                               endpoint_device_.Receive());
-    } else if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
-      // Capture the default playback stream.
-      hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
-                                               endpoint_device_.Receive());
-    } else {
-      hr = enumerator->GetDevice(base::UTF8ToUTF16(device_id_).c_str(),
-                                 endpoint_device_.Receive());
-    }
+  } else if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
+    // Capture the default playback stream.
+    hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
+                                             endpoint_device_.Receive());
+  } else {
+    hr = enumerator->GetDevice(base::UTF8ToUTF16(device_id_).c_str(),
+                               endpoint_device_.Receive());
   }
 
   if (FAILED(hr))
     return hr;
 
   // Verify that the audio endpoint device is active, i.e., the audio
   // adapter that connects to the endpoint device is present and enabled.
   DWORD state = DEVICE_STATE_DISABLED;
   hr = endpoint_device_->GetState(&state);
   if (FAILED(hr))
@@ skipping 77 matching lines @@
 }
 
 HRESULT WASAPIAudioInputStream::InitializeAudioEngine() {
   DWORD flags;
   // Use event-driven mode only fo regular input devices. For loopback the
   // EVENTCALLBACK flag is specified when intializing
   // |audio_render_client_for_loopback_|.
   if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
     flags = AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
   } else {
-    flags =
-      AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
+    flags = AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
   }
 
   // Initialize the audio stream between the client and the device.
   // We connect indirectly through the audio engine by using shared mode.
   // Note that, |hnsBufferDuration| is set of 0, which ensures that the
   // buffer is never smaller than the minimum buffer size needed to ensure
   // that glitches do not occur between the periodic processing passes.
   // This setting should lead to lowest possible latency.
   HRESULT hr = audio_client_->Initialize(
       AUDCLNT_SHAREMODE_SHARED,
       flags,
       0,  // hnsBufferDuration
       0,
       &format_,
-      (effects_ & AudioParameters::DUCKING) ? &kCommunicationsSessionId : NULL);
+      device_id_ == AudioManagerBase::kCommunicationsDeviceId ?
+          &kCommunicationsSessionId : nullptr);
 
   if (FAILED(hr))
     return hr;
 
   // Retrieve the length of the endpoint buffer shared between the client
   // and the audio engine. The buffer length determines the maximum amount
   // of capture data that the audio engine can read from the endpoint buffer
   // during a single processing pass.
   // A typical value is 960 audio frames <=> 20ms @ 48kHz sample rate.
   hr = audio_client_->GetBufferSize(&endpoint_buffer_size_frames_);
@@ skipping 74 matching lines @@
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }
 
 }  // namespace media