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

media/audio/win/audio_manager_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/audio_io.h"
 
 #include <windows.h>
 #include <objbase.h>  // This has to be before initguid.h
 #include <initguid.h>
 #include <mmsystem.h>
@@ skipping 111 matching lines @@
   //  - The entire Windows audio stack was rewritten for Windows Vista and wave
   //    out performance was degraded compared to XP.
   //  - The regression was fixed in Windows 7 and most configurations will work
   //    with 2, but some (e.g., some Sound Blasters) still need 3.
   //  - Some XP configurations (even multi-processor ones) also need 3.
   return (base::win::GetVersion() == base::win::VERSION_VISTA) ? 4 : 3;
 }
 
 AudioManagerWin::AudioManagerWin(AudioLogFactory* audio_log_factory)
     : AudioManagerBase(audio_log_factory),
-      enumeration_type_(kUninitializedEnumeration) {
+      enumeration_type_(kUninitializedEnumeration),
+      // |CoreAudioUtil::IsSupported()| uses static variables to avoid doing
+      // multiple initializations.  This is however not thread safe.
+      // So, here we call it explicitly before we kick off the audio thread
+      // or do any other work.
+      core_audio_supported_(CoreAudioUtil::IsSupported()) {

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

Heh, I just removed this from the startup path last week... Avoiding any
unnecessary LoadLibrary we can there seems like a good idea.

Also there are other users of that call, it'd be better to make IsSupported()
thread safe than have every other caller figure out how to deal with the lack of
thread safety.

It should be possible to just use an atomic set in IsSupported() to fix this.

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

Did you measure this impact?  It's not clear to me if the LoadLibrary calls are
there to actually load the DLLs or just to pin them (in which case they were
already loaded)/check for their existence.

In the former, most common case), the cost of the LoadLibrary call would be
negligible.
In the rare case where these DLLs are actually missing (again, if my assumption
is correct), then this isn't exactly fast, but imho that's fine and it allows us
to fail immediately.

I can implement some sort of an atomic set that may call LoadLibrary and/or
CanCreateDeviceEnumerator more than once while still avoiding the race issue,
but whether or not that gives us better or worse performance is not clear to me.
 My gut feeling right now is that it will be a net-negative for the most common
case.

In any case, this is a regression so we need to fix it one way or another so if
you have data to support that this was impacting the startup path, then that
would be good to know.

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

Henrik - maybe you can weigh in here as well with some background?

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

Link to original issue which triggered the change:
https://code.google.com/p/chromium/issues/detail?id=166397.

[DaleCurtis, 2014/02/06 19:09:21]

Here's the CL I moved it off in: https://codereview.chromium.org/144613003/
which was triggered by discussion on http://crbug.com/311259 where I noted
upgrading audio drivers resolved some issues for my home machine.  Despite some
unclear interactions with the GPU it seemed a reasonable change to make.

I haven't found any perf benefits on the bots though, so I can't back up my
claims.  It seems reasonable that there are users out there which may have a
slow LoadLibrary call here though.

Apologies for breaking the tests!  For this race condition is it not enough to
have the unittest pump the audio message loop once so that initialization is
allowed to complete?  Note the changes I made to the enumeration tests to do
this in the above CL.

Is there another caller that you're worried about?

   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
   // WARNING: This is executed on the UI loop, do not add any code here which
   // loads libraries or attempts to call out into the OS.  Instead add such code
   // to the InitializeOnAudioThread() method below.
 
   // Task must be posted last to avoid races from handing out "this" to the
   // audio thread.
   GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
       &AudioManagerWin::InitializeOnAudioThread, base::Unretained(this)));
@@ skipping 11 matching lines @@
   return (::waveOutGetNumDevs() != 0);
 }
 
 bool AudioManagerWin::HasAudioInputDevices() {
   return (::waveInGetNumDevs() != 0);
 }
 
 void AudioManagerWin::InitializeOnAudioThread() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
-  if (CoreAudioUtil::IsSupported()) {
+  if (core_audio_supported_) {
     // Use the MMDevice API for device enumeration if Vista or higher.
     enumeration_type_ = kMMDeviceEnumeration;
 
     // AudioDeviceListenerWin must be initialized on a COM thread and should
     // only be used if WASAPI / Core Audio is supported.
     output_device_listener_.reset(new AudioDeviceListenerWin(BindToCurrentLoop(
         base::Bind(&AudioManagerWin::NotifyAllOutputDeviceChangeListeners,
                    base::Unretained(this)))));
   } else {
     // Use the Wave API for device enumeration if XP or lower.
@@ skipping 66 matching lines @@
     if (device_found)
       return GetDeviceAndDriverInfo(device_info, &device_data);
   }
 
   return base::string16();
 }
 
 void AudioManagerWin::ShowAudioInputSettings() {
   std::wstring program;
   std::string argument;
-  if (!CoreAudioUtil::IsSupported()) {
+  if (!core_audio_supported_) {
     program = L"sndvol32.exe";
     argument = "-R";
   } else {
     program = L"control.exe";
     argument = "mmsys.cpl,,1";
   }
 
   base::FilePath path;
   PathService::Get(base::DIR_SYSTEM, &path);
   path = path.Append(program);
@@ skipping 35 matching lines @@
   GetAudioDeviceNamesImpl(true, device_names);
 }
 
 void AudioManagerWin::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
   GetAudioDeviceNamesImpl(false, device_names);
 }
 
 AudioParameters AudioManagerWin::GetInputStreamParameters(
     const std::string& device_id) {
-  int sample_rate = 48000;
-  ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
-  if (CoreAudioUtil::IsSupported()) {
-    int hw_sample_rate = WASAPIAudioInputStream::HardwareSampleRate(device_id);
-    if (hw_sample_rate)
-      sample_rate = hw_sample_rate;
-    channel_layout =
-        WASAPIAudioInputStream::HardwareChannelCount(device_id) == 1 ?
-            CHANNEL_LAYOUT_MONO : CHANNEL_LAYOUT_STEREO;
+  if (!core_audio_supported_) {
+    return AudioParameters(
+        AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO, 0, 48000,
+        16, kFallbackBufferSize, AudioParameters::NO_EFFECTS);
   }
 
-  // TODO(Henrika): improve the default buffer size value for input stream.
-  return AudioParameters(
-      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
-      sample_rate, 16, kFallbackBufferSize);
+  return WASAPIAudioInputStream::GetInputStreamParameters(device_id);
 }
 
 std::string AudioManagerWin::GetAssociatedOutputDeviceID(
     const std::string& input_device_id) {
-  if (!CoreAudioUtil::IsSupported()) {
+  if (!core_audio_supported_) {
     NOTIMPLEMENTED()
         << "GetAssociatedOutputDeviceID is not supported on this OS";
     return std::string();
   }
   return CoreAudioUtil::GetMatchingOutputDeviceID(input_device_id);
 }
 
 // Factory for the implementations of AudioOutputStream for AUDIO_PCM_LINEAR
 // mode.
 // - PCMWaveOutAudioOutputStream: Based on the waveOut API.
@@ skipping 15 matching lines @@
 // - PCMWaveOutAudioOutputStream: Based on the waveOut API.
 // - WASAPIAudioOutputStream: Based on Core Audio (WASAPI) API.
 AudioOutputStream* AudioManagerWin::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   if (params.channels() > kWinMaxChannels)
     return NULL;
 
-  if (!CoreAudioUtil::IsSupported()) {
+  if (!core_audio_supported_) {
     // Fall back to Windows Wave implementation on Windows XP or lower.
     DLOG_IF(ERROR, !device_id.empty() &&
         device_id != AudioManagerBase::kDefaultDeviceId)
         << "Opening by device id not supported by PCMWaveOutAudioOutputStream";
     DVLOG(1) << "Using WaveOut since WASAPI requires at least Vista.";
     return new PCMWaveOutAudioOutputStream(
         this, params, NumberOfWaveOutBuffers(), WAVE_MAPPER);
   }
 
   // TODO(rtoy): support more than stereo input.
@@ skipping 21 matching lines @@
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return CreatePCMWaveInAudioInputStream(params, device_id);
 }
 
 // Factory for the implementations of AudioInputStream for
 // AUDIO_PCM_LOW_LATENCY mode.
 AudioInputStream* AudioManagerWin::MakeLowLatencyInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   AudioInputStream* stream = NULL;
-  if (!CoreAudioUtil::IsSupported()) {
+  if (!core_audio_supported_) {
     // Fall back to Windows Wave implementation on Windows XP or lower.
     DVLOG(1) << "Using WaveIn since WASAPI requires at least Vista.";
     stream = CreatePCMWaveInAudioInputStream(params, device_id);
   } else {
     stream = new WASAPIAudioInputStream(this, params, device_id);
   }
 
   return stream;
 }
 
 std::string AudioManagerWin::GetDefaultOutputDeviceID() {
-  if (!CoreAudioUtil::IsSupported())
+  if (!core_audio_supported_)
     return std::string();
   return CoreAudioUtil::GetDefaultOutputDeviceID();
 }
 
 AudioParameters AudioManagerWin::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
-  const bool core_audio_supported = CoreAudioUtil::IsSupported();
-  DLOG_IF(ERROR, !core_audio_supported && !output_device_id.empty())
+  DLOG_IF(ERROR, !core_audio_supported_ && !output_device_id.empty())
       << "CoreAudio is required to open non-default devices.";
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int sample_rate = 48000;
   int buffer_size = kFallbackBufferSize;
   int bits_per_sample = 16;
   int input_channels = 0;
-  bool use_input_params = !core_audio_supported;
-  if (core_audio_supported) {
+  bool use_input_params = !core_audio_supported_;
+  if (core_audio_supported_) {
     if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio)) {
       // TODO(rtoy): tune these values for best possible WebAudio
       // performance. WebRTC works well at 48kHz and a buffer size of 480
       // samples will be used for this case. Note that exclusive mode is
       // experimental. This sample rate will be combined with a buffer size of
       // 256 samples, which corresponds to an output delay of ~5.33ms.
       sample_rate = 48000;
       buffer_size = 256;
       if (input_params.IsValid())
         channel_layout = input_params.channel_layout();
@@ skipping 11 matching lines @@
       } else {
         use_input_params = true;
       }
     }
   }
 
   if (input_params.IsValid()) {
     // If the user has enabled checking supported channel layouts or we don't
     // have a valid channel layout yet, try to use the input layout.  See bugs
     // http://crbug.com/259165 and http://crbug.com/311906 for more details.
-    if (core_audio_supported &&
+    if (core_audio_supported_ &&
         (cmd_line->HasSwitch(switches::kTrySupportedChannelLayouts) ||
          channel_layout == CHANNEL_LAYOUT_UNSUPPORTED)) {
       // Check if it is possible to open up at the specified input channel
       // layout but avoid checking if the specified layout is the same as the
       // hardware (preferred) layout. We do this extra check to avoid the
       // CoreAudioUtil::IsChannelLayoutSupported() overhead in most cases.
       if (input_params.channel_layout() != channel_layout) {
         // TODO(henrika): Internally, IsChannelLayoutSupported does many of the
         // operations that have already been done such as opening up a client
         // and fetching the WAVEFORMATPCMEX format.  Ideally we should only do
@@ skipping 50 matching lines @@
   return new PCMWaveInAudioInputStream(this, params, kNumInputBuffers,
                                        xp_device_id);
 }
 
 /// static
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
   return new AudioManagerWin(audio_log_factory);
 }
 
 }  // namespace media