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) {
+      // |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.
+      enumeration_type_(CoreAudioUtil::IsSupported() ?
+          kMMDeviceEnumeration : kWaveEnumeration) {
   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()) {
-    // Use the MMDevice API for device enumeration if Vista or higher.
-    enumeration_type_ = kMMDeviceEnumeration;
-
+  if (core_audio_supported()) {
     // 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.
-    enumeration_type_ = kWaveEnumeration;
   }
 }
 
 void AudioManagerWin::ShutdownOnAudioThread() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_device_listener_.reset();
 }
 
 base::string16 AudioManagerWin::GetAudioInputDeviceModel() {
   // Get the default audio capture device and its device interface name.
@@ skipping 55 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);
   CommandLine command_line(path);
   command_line.AppendArg(argument);
   base::LaunchProcess(command_line, base::LaunchOptions(), NULL);
 }
 
 void AudioManagerWin::GetAudioDeviceNamesImpl(
     bool input,
     AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
-  DCHECK(enumeration_type() !=  kUninitializedEnumeration);
   // Enumerate all active audio-endpoint capture devices.
   if (enumeration_type() == kWaveEnumeration) {
     // Utilize the Wave API for Windows XP.
     if (input)
       GetInputDeviceNamesWinXP(device_names);
     else
       GetOutputDeviceNamesWinXP(device_names);
   } else {
     // Utilize the MMDevice API (part of Core Audio) for Vista and higher.
     if (input)
@@ skipping 15 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 20 matching lines @@
     const AudioParameters& params, const std::string& device_id) {
   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());
+  DVLOG(1) << "MakeLowLatencyInputStream: " << device_id;
   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