Add basic support for "googDucking" to getUserMedia on Windows.

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"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 
 namespace media {
 
 WASAPIAudioInputStream::WASAPIAudioInputStream(
-    AudioManagerWin* manager, const AudioParameters& params,
+    AudioManagerWin* manager,
+    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) {
   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";
 
   // Set up the desired capture format specified by the client.
   format_.nSamplesPerSec = params.sample_rate();
   format_.wFormatTag = WAVE_FORMAT_PCM;
@@ skipping 23 matching lines @@
   stop_capture_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(stop_capture_event_.IsValid());
 
   ms_to_frame_count_ = static_cast<double>(params.sample_rate()) / 1000.0;
 
   LARGE_INTEGER performance_frequency;
   if (QueryPerformanceFrequency(&performance_frequency)) {
     perf_count_to_100ns_units_ =
         (10000000.0 / static_cast<double>(performance_frequency.QuadPart));
   } else {
-    LOG(ERROR) <<  "High-resolution performance counters are not supported.";
-    perf_count_to_100ns_units_ = 0.0;
+    DLOG(ERROR) << "High-resolution performance counters are not supported.";
   }
 }
 
 WASAPIAudioInputStream::~WASAPIAudioInputStream() {}
 
 bool WASAPIAudioInputStream::Open() {
   DCHECK(CalledOnValidThread());
   // Verify that we are not already opened.
   if (opened_)
     return false;
@@ skipping 149 matching lines @@
 
   // Retrieve the current volume level. The value is in the range 0.0 to 1.0.
   float level = 0.0f;
   HRESULT hr = simple_audio_volume_->GetMasterVolume(&level);
   DLOG_IF(WARNING, FAILED(hr)) << "Failed to get input master volume.";
 
   return static_cast<double>(level);
 }
 
 // static
-int WASAPIAudioInputStream::HardwareSampleRate(
+AudioParameters WASAPIAudioInputStream::GetInputStreamParameters(
     const std::string& device_id) {
+  int sample_rate = 48000;
+  ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
+
   base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
-  HRESULT hr = GetMixFormat(device_id, &audio_engine_mix_format);
-  if (FAILED(hr))
-    return 0;
+  if (SUCCEEDED(GetMixFormat(device_id, &audio_engine_mix_format))) {
+    sample_rate = static_cast<int>(audio_engine_mix_format->nSamplesPerSec);
+    channel_layout = audio_engine_mix_format->nChannels == 1 ?
+        CHANNEL_LAYOUT_MONO : CHANNEL_LAYOUT_STEREO;
+  }
 
-  return static_cast<int>(audio_engine_mix_format->nSamplesPerSec);
+  int effects = AudioParameters::NO_EFFECTS;
+  // For non-loopback devices, advertise that ducking is supported.
+  if (device_id != AudioManagerBase::kLoopbackInputDeviceId)
+    effects |= AudioParameters::DUCKING;
+
+  // Use 10ms frame size as default.
+  int frames_per_buffer = sample_rate / 100;
+  return AudioParameters(
+      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, 0, sample_rate,
+      16, frames_per_buffer, effects);
 }
 
 // static
-uint32 WASAPIAudioInputStream::HardwareChannelCount(
-    const std::string& device_id) {
-  base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
-  HRESULT hr = GetMixFormat(device_id, &audio_engine_mix_format);
-  if (FAILED(hr))
-    return 0;
-
-  return static_cast<uint32>(audio_engine_mix_format->nChannels);
-}
-
-// static
 HRESULT WASAPIAudioInputStream::GetMixFormat(const std::string& device_id,
                                              WAVEFORMATEX** device_format) {
   // It is assumed that this static method is called from a COM thread, i.e.,
   // CoInitializeEx() is not called here to avoid STA/MTA conflicts.
   ScopedComPtr<IMMDeviceEnumerator> enumerator;
   HRESULT hr = enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), NULL,
                                          CLSCTX_INPROC_SERVER);
   if (FAILED(hr))
     return hr;
 
   ScopedComPtr<IMMDevice> endpoint_device;
   if (device_id == AudioManagerBase::kDefaultDeviceId) {
     // Retrieve the default capture audio endpoint.
     hr = enumerator->GetDefaultAudioEndpoint(eCapture, eConsole,
                                              endpoint_device.Receive());
   } else if (device_id == AudioManagerBase::kLoopbackInputDeviceId) {
-    // Capture the default playback stream.
+    // Get the mix format of the default playback stream.
     hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
                                              endpoint_device.Receive());
   } else {
     // Retrieve a capture endpoint device that is specified by an endpoint
     // device-identification string.
     hr = enumerator->GetDevice(base::UTF8ToUTF16(device_id).c_str(),
                                endpoint_device.Receive());
   }
   if (FAILED(hr))
     return hr;
@@ skipping 172 matching lines @@
   if (FAILED(hr))
     return hr;
 
   // Retrieve the IMMDevice by using the specified role or the specified
   // unique endpoint device-identification string.
   // TODO(henrika): possibly add support for the eCommunications as well.
   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,
+
+    // If the caller has requested to turn on ducking, we select the default
+    // communications device instead of the default capture device.
+    // This implicitly turns on ducking and allows the user to control the
+    // attenuation level.
+    ERole role = (effects_ & AudioParameters::DUCKING) ?
+        eCommunications : eConsole;
+
+    hr = enumerator->GetDefaultAudioEndpoint(eCapture, role,
                                              endpoint_device_.Receive());
   } else if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
     // Capture the default playback stream.
     hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
                                              endpoint_device_.Receive());
   } else {
     // Retrieve a capture endpoint device that is specified by an endpoint
     // device-identification string.
+    // TODO(tommi): Opt into ducking for non-default audio devices.
+    DLOG_IF(WARNING, effects_ & AudioParameters::DUCKING)
+        << "Ducking has been requested for a non-default device."
+           "Not implemented.";
     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;
@@ skipping 188 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