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 ?

[DaleCurtis, 2014/02/05 22:15:43]

Won't this blow up on multichannel input systems?  Though do we even support
those?  Should you instead use GuessChannelLayout?

[tommi (sloooow) - chröme, 2014/02/06 11:50:34]

Henrik - I guess this is rather a question for you I think.

This is not new code in this CL but just moved from the implementation from
AudioManagerWin::GetInputStreamParameters to here. (and saved one call to
GetMixFormat() by doing so).

[henrika (OOO until Aug 14), 2014/02/06 12:07:56]

Well, as Tommi states, nothing is changed here. I must admit that I have never
encountered a multi-channel input device and have never seen and crash reports
related trying to open such a device in stereo.

Guess the best answer I can give is: I don't know but would have to test on a
multi-channel input device to provide a correct answer.

Feel free to add a TODO on me here.

[tommi (sloooow) - chröme, 2014/02/06 12:55:34]

Multichannel devices that I've tried, all support stereo so I think this is
fine.  Those sorts of devices are actually fairly common (think gamers with 5.1
setups), so we would have heard a lot of screaming by now if it didn't work.

[henrika (OOO until Aug 14), 2014/02/06 13:11:28]

Hope I am not repeating anything here but we are talking about multi-channel
input; right?

[tommi (sloooow) - chröme, 2014/02/06 13:28:33]

Ah, sorry, brainfart :)  Yes we are.  I haven't tested with multi-channel input
devices.  I have tested with devices that have multiple inputs but none that has
a single input device with more than two channels.  Even binaural recording only
uses two sources (and even then they are typically consumed as two mono
sources).

Having said that, we might be looking at a hybrid case of this (>2 channel
input) soon so we'll see how this is handled then.  But for now and for the
purposes of this CL I don't think we should be rocking the boat too much.

+        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;

[henrika (OOO until Aug 14), 2014/02/05 16:19:01]

Have you been able to verify this change somehow? Rather big change.

[no longer working on chromium, 2014/02/05 16:43:25]

I did a quick check on the code, speech is using their native buffer size
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/sp....

And AFAIK Pepper should also use their own buffer size as well.
So I think such change is fine.

BTW, should we change the native buffer size to 10ms as well on the output side?

Now it is not exactly 10ms.

[tommi (sloooow) - chröme, 2014/02/06 11:50:34]

In practice it's actually not a big change for two reasons:
1. As Shijing found out as well, it turns out nobody currently uses this value! 
Previously it was 2048 which would have caused noticeable latency but all
callers of GetInputStreamParameters currently use their own buffer size and as
has been discussed, it is most of the time exactly this value which is why I
chose it as the default.

2. There is one place that checks this value and compares it against another
value (inside WebRtcAudioCapturer::EnablePeerConnectionMode) that this might
affect.  If it does affect it (which is what I've consulted Shijing on), then
there's a bug in WebRtcAudioCapturer::EnablePeerConnectionMode.  If it does not
affect it, then we have improved WebRtcAudioCapturer::EnablePeerConnectionMode
by avoiding to have to inject an extra "capturer source" for a stream.
However, practially speaking that special case is there only for WebAudio which
uses a non-default buffer size that is much smaller than 10ms, so this is not an
issue.

+  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