Wire up AGC to the MediaStreamAudioProcessor

content/renderer/media/media_stream_audio_processor_options.cc

 // Copyright 2013 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 "content/renderer/media/media_stream_audio_processor_options.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 21 matching lines @@
     webrtc::MediaConstraintsInterface::kValueTrue },
 #endif
   { webrtc::MediaConstraintsInterface::kAutoGainControl,
     webrtc::MediaConstraintsInterface::kValueTrue },
   { webrtc::MediaConstraintsInterface::kExperimentalAutoGainControl,
     webrtc::MediaConstraintsInterface::kValueTrue },
   { webrtc::MediaConstraintsInterface::kNoiseSuppression,
     webrtc::MediaConstraintsInterface::kValueTrue },
   { webrtc::MediaConstraintsInterface::kHighpassFilter,
     webrtc::MediaConstraintsInterface::kValueTrue },
-  // TODO(xians): Verify if it is OK to set typing detection to kValueFalse as
-  // default.
   { webrtc::MediaConstraintsInterface::kTypingNoiseDetection,
-    webrtc::MediaConstraintsInterface::kValueFalse },
+    webrtc::MediaConstraintsInterface::kValueTrue },
 };
 
 } // namespace
 
 void ApplyFixedAudioConstraints(RTCMediaConstraints* constraints) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {
     bool already_set_value;
     if (!webrtc::FindConstraint(constraints, kDefaultAudioConstraints[i].key,
                                 &already_set_value, NULL)) {
       constraints->AddMandatory(kDefaultAudioConstraints[i].key,
@@ skipping 27 matching lines @@
   return false;
 }
 
 bool GetPropertyFromConstraints(const MediaConstraintsInterface* constraints,
                                 const std::string& key) {
   bool value = false;
   return webrtc::FindConstraint(constraints, key, &value, NULL) && value;
 }
 
 void EnableEchoCancellation(AudioProcessing* audio_processing) {
 #if defined(OS_IOS)

[ajm, 2014/01/22 21:50:55]

For echo cancellation you have the disable switch here, but for e.g. typing
detection you have it in:
MediaStreamAudioProcessor::InitializeAudioProcessingModule

Probably better to standardize on one place. Either move this out to Initialize,
or move the typing detection platform-specific decision to
EnableTypingDetection.

[no longer working on chromium, 2014/01/23 12:46:08]

Done.

   // On iOS, VPIO provides built-in EC and AGC.
   return;
 #elif defined(OS_ANDROID)
   // Mobile devices are using AECM.
   int err = audio_processing->echo_control_mobile()->Enable(true);
   err |= audio_processing->echo_control_mobile()->set_routing_mode(

[ajm, 2014/01/22 21:50:55]

nit: it's slightly (though probably unmeasurably) better to configure the
components before enabling.

[no longer working on chromium, 2014/01/23 12:46:08]

Done.

       webrtc::EchoControlMobile::kSpeakerphone);
   CHECK_EQ(err, 0);
 #else
   int err = audio_processing->echo_cancellation()->Enable(true);
   err |= audio_processing->echo_cancellation()->set_suppression_level(
       webrtc::EchoCancellation::kHighSuppression);
 
   // Enable the metrics for AEC.
   err |= audio_processing->echo_cancellation()->enable_metrics(true);
   err |= audio_processing->echo_cancellation()->enable_delay_logging(true);
   CHECK_EQ(err, 0);
 #endif
 }
 
 void EnableNoiseSuppression(AudioProcessing* audio_processing) {
   int err = audio_processing->noise_suppression()->set_level(
       webrtc::NoiseSuppression::kHigh);
   err |= audio_processing->noise_suppression()->Enable(true);
   CHECK_EQ(err, 0);
 }
 
 void EnableHighPassFilter(AudioProcessing* audio_processing) {
   CHECK_EQ(audio_processing->high_pass_filter()->Enable(true), 0);
 }
 
-// TODO(xians): stereo swapping
 void EnableTypingDetection(AudioProcessing* audio_processing) {
   int err = audio_processing->voice_detection()->Enable(true);
   err |= audio_processing->voice_detection()->set_likelihood(
       webrtc::VoiceDetection::kVeryLowLikelihood);
   CHECK_EQ(err, 0);
 }
 
 void EnableExperimentalEchoCancellation(AudioProcessing* audio_processing) {
   webrtc::Config config;
   config.Set<webrtc::DelayCorrection>(new webrtc::DelayCorrection(true));
@@ skipping 20 matching lines @@
 #endif
   if (audio_processing->StartDebugRecording(file_name.c_str()))
     DLOG(ERROR) << "Fail to start AEC debug recording";
 }
 
 void StopAecDump(AudioProcessing* audio_processing) {
   if (audio_processing->StopDebugRecording())
     DLOG(ERROR) << "Fail to stop AEC debug recording";
 }
 
+void EnableAutomaticGainControl(AudioProcessing* audio_processing) {
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  const webrtc::GainControl::Mode mode = webrtc::GainControl::kAdaptiveAnalog;
+#else
+  const webrtc::GainControl::Mode mode = webrtc::GainControl::kAdaptiveAnalog;
+#endif
+  int err = audio_processing->gain_control()->set_mode(mode);
+  err |= audio_processing->gain_control()->Enable(true);
+  CHECK_EQ(err, 0);
+}
+
 }  // namespace content