Turn audio ducking on by default on Windows again.

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"
 #include "media/audio/win/avrt_wrapper_win.h"
+#include "media/audio/win/core_audio_util_win.h"
 #include "media/base/audio_bus.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 
 namespace media {
 namespace {
 
 // Returns true if |device| represents the default communication capture device.
 bool IsDefaultCommunicationDevice(IMMDeviceEnumerator* enumerator,
@@ skipping 68 matching lines @@
 
   LARGE_INTEGER performance_frequency;
   if (QueryPerformanceFrequency(&performance_frequency)) {
     perf_count_to_100ns_units_ =
         (10000000.0 / static_cast<double>(performance_frequency.QuadPart));
   } else {
     DLOG(ERROR) << "High-resolution performance counters are not supported.";
   }
 }
 
-WASAPIAudioInputStream::~WASAPIAudioInputStream() {}
+WASAPIAudioInputStream::~WASAPIAudioInputStream() {
+  DCHECK(CalledOnValidThread());
+}
 
 bool WASAPIAudioInputStream::Open() {
   DCHECK(CalledOnValidThread());
   // Verify that we are not already opened.
   if (opened_)
     return false;
 
   // Obtain a reference to the IMMDevice interface of the capturing
   // device with the specified unique identifier or role which was
   // set at construction.
@@ skipping 394 matching lines @@
     // to be valid matches.
     hr = enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
                                              endpoint_device_.Receive());
     if (endpoint_device_ && 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_) {
     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.
@@ skipping 107 matching lines @@
     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_,
-                                         NULL);
+  HRESULT hr = audio_client_->Initialize(
+      AUDCLNT_SHAREMODE_SHARED,
+      flags,
+      0,  // hnsBufferDuration
+      0,
+      &format_,
+      (effects_ & AudioParameters::DUCKING) ? &kCommunicationsSessionId : NULL);
+
   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_);
   if (FAILED(hr))
@@ skipping 73 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