Use new uniform interface to configure AGC

New interface will let configuring AGC1 and AGC2 both be done through
AudioProcessing::Config. Therefore, it would be betther to move the code
for configuring to one single function, to have a concentrated place to
hold the configuring logic.

config before/after the CL and enabled/disabled exp AGC, on desktop.

Bug: 953804
Test: Pass added unit test. Print out apm config, and see the exact same
Change-Id: If4d90902b960a23dd98333534fe0086079524d6a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1582969Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Armando Miraglia <armax@chromium.org>
Commit-Queue: Kehuang Li <kehuangli@chromium.org>
Cr-Commit-Position: refs/heads/master@{#657624}

content/renderer/media/stream/media_stream_audio_processor.cc

@@ -634,35 +634,31 @@ void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
                             &pre_amplifier_fixed_gain_factor,
                             &gain_control_compression_gain_db);
 
-  if (properties.goog_auto_gain_control) {
-    blink::EnableAutomaticGainControl(audio_processing_.get(),
-                                      gain_control_compression_gain_db);
-  }
-
   webrtc::AudioProcessing::Config apm_config = audio_processing_->GetConfig();
   apm_config.high_pass_filter.enabled = properties.goog_highpass_filter;
 
-  if (properties.goog_experimental_auto_gain_control) {
-    apm_config.gain_controller2.enabled =
-        base::FeatureList::IsEnabled(features::kWebRtcHybridAgc);
-    apm_config.gain_controller2.fixed_digital.gain_db = 0.f;
-
-    apm_config.gain_controller2.adaptive_digital.enabled = true;
-
-    const bool use_peaks_not_rms = base::GetFieldTrialParamByFeatureAsBool(
-        features::kWebRtcHybridAgc, "use_peaks_not_rms", false);
-    using Shortcut =
-        webrtc::AudioProcessing::Config::GainController2::LevelEstimator;
-    apm_config.gain_controller2.adaptive_digital.level_estimator =
-        use_peaks_not_rms ? Shortcut::kPeak : Shortcut::kRms;
-
-    const int saturation_margin = base::GetFieldTrialParamByFeatureAsInt(
-        features::kWebRtcHybridAgc, "saturation_margin", -1);
-    if (saturation_margin != -1) {
-      apm_config.gain_controller2.adaptive_digital.extra_saturation_margin_db =
-          saturation_margin;
+  if (properties.goog_auto_gain_control ||
+      properties.goog_experimental_auto_gain_control) {
+    bool use_hybrid_agc = false;
+    base::Optional<bool> use_peaks_not_rms;
+    base::Optional<int> saturation_margin;
+    if (properties.goog_experimental_auto_gain_control) {
+      use_hybrid_agc = base::FeatureList::IsEnabled(features::kWebRtcHybridAgc);
+      if (use_hybrid_agc) {
+        DCHECK(properties.goog_auto_gain_control)
+            << "Cannot enable hybrid AGC when AGC is disabled.";
+      }
+      use_peaks_not_rms = base::GetFieldTrialParamByFeatureAsBool(
+          features::kWebRtcHybridAgc, "use_peaks_not_rms", false);
+      saturation_margin = base::GetFieldTrialParamByFeatureAsInt(
+          features::kWebRtcHybridAgc, "saturation_margin", -1);
     }
+    blink::ConfigAutomaticGainControl(
+        &apm_config, properties.goog_auto_gain_control,
+        properties.goog_experimental_auto_gain_control, use_hybrid_agc,
+        use_peaks_not_rms, saturation_margin, gain_control_compression_gain_db);
   }
+
   blink::ConfigPreAmplifier(&apm_config, pre_amplifier_fixed_gain_factor);
   audio_processing_->ApplyConfig(apm_config);
 

third_party/blink/public/platform/modules/mediastream/media_stream_audio_processor_options.h

@@ -125,10 +125,14 @@ BLINK_PLATFORM_EXPORT void GetExtraGainConfig(
     base::Optional<double>* pre_amplifier_fixed_gain_factor,
     base::Optional<double>* gain_control_compression_gain_db);
 
-// Enables automatic gain control. If optional |fixed_gain| is set, will set the
-// gain control mode to use the fixed gain.
-BLINK_PLATFORM_EXPORT void EnableAutomaticGainControl(
-    AudioProcessing* audio_processing,
+// Enables automatic gain control with flags and optional configures.
+BLINK_PLATFORM_EXPORT void ConfigAutomaticGainControl(
+    webrtc::AudioProcessing::Config* apm_config,
+    bool agc_enabled,
+    bool experimental_agc_enabled,
+    bool use_hybrid_agc,
+    base::Optional<bool> hybrid_agc_use_peaks_not_rms,
+    base::Optional<int> hybrid_agc_saturation_margin,
     base::Optional<double> compression_gain_db);
 
 // Enables pre-amplifier with given gain factor if the optional |factor| is set.

third_party/blink/renderer/platform/BUILD.gn

@@ -1681,6 +1681,7 @@ jumbo_source_set("blink_platform_unittests_sources") {
     "bindings/parkable_string_test.cc",
     "bindings/runtime_call_stats_test.cc",
     "exported/file_path_conversion_test.cc",
+    "exported/mediastream/media_stream_audio_processor_options_test.cc",
     "exported/mediastream/webrtc_uma_histograms_test.cc",
     "exported/notification_data_conversions_test.cc",
     "exported/web_canonical_cookie_test.cc",

third_party/blink/renderer/platform/exported/mediastream/media_stream_audio_processor_options.cc

@@ -183,24 +183,55 @@ void GetExtraGainConfig(
       GetGainControlCompressionGain(config.get());
 }
 
-void EnableAutomaticGainControl(AudioProcessing* audio_processing,
-                                base::Optional<double> compression_gain_db) {
+void ConfigAutomaticGainControl(
+    webrtc::AudioProcessing::Config* apm_config,
+    bool agc_enabled,
+    bool experimental_agc_enabled,
+    bool use_hybrid_agc,
+    base::Optional<bool> hybrid_agc_use_peaks_not_rms,
+    base::Optional<int> hybrid_agc_saturation_margin,
+    base::Optional<double> compression_gain_db) {
+  const bool use_fixed_digital_agc1 =
+      agc_enabled && !use_hybrid_agc && compression_gain_db.has_value();
+
+  // Configure AGC1.
+  if (agc_enabled) {
+    apm_config->gain_controller1.enabled = true;
+    if (use_fixed_digital_agc1) {
+      apm_config->gain_controller1.mode =
+          webrtc::AudioProcessing::Config::GainController1::Mode::kFixedDigital;
+      apm_config->gain_controller1.compression_gain_db =
+          compression_gain_db.value();
+    } else {
+      apm_config->gain_controller1.mode =
 #if defined(OS_ANDROID)
-  const webrtc::GainControl::Mode mode = webrtc::GainControl::kFixedDigital;
+          webrtc::AudioProcessing::Config::GainController1::Mode::kFixedDigital;
 #else
-  const webrtc::GainControl::Mode mode = webrtc::GainControl::kAdaptiveAnalog;
+          webrtc::AudioProcessing::Config::GainController1::Mode::
+              kAdaptiveAnalog;
 #endif
-  int err = 0;
-  if (!!compression_gain_db) {
-    err |= audio_processing->gain_control()->set_mode(
-        webrtc::GainControl::kFixedDigital);
-    err |= audio_processing->gain_control()->set_compression_gain_db(
-        compression_gain_db.value());
-  } else {
-    err |= audio_processing->gain_control()->set_mode(mode);
+    }
+  }
+
+  // Configure AGC2.
+  if (experimental_agc_enabled) {
+    DCHECK(hybrid_agc_use_peaks_not_rms.has_value() &&
+           hybrid_agc_saturation_margin.has_value());
+    apm_config->gain_controller2.enabled = use_hybrid_agc;
+    apm_config->gain_controller2.fixed_digital.gain_db = 0.f;
+    apm_config->gain_controller2.adaptive_digital.enabled = true;
+
+    using LevelEstimator =
+        webrtc::AudioProcessing::Config::GainController2::LevelEstimator;
+    apm_config->gain_controller2.adaptive_digital.level_estimator =
+        hybrid_agc_use_peaks_not_rms.value() ? LevelEstimator::kPeak
+                                             : LevelEstimator::kRms;
+
+    if (hybrid_agc_saturation_margin.value() != -1) {
+      apm_config->gain_controller2.adaptive_digital.extra_saturation_margin_db =
+          hybrid_agc_saturation_margin.value();
+    }
   }
-  err |= audio_processing->gain_control()->Enable(true);
-  CHECK_EQ(err, 0);
 }
 
 void ConfigPreAmplifier(webrtc::AudioProcessing::Config* apm_config,

third_party/blink/renderer/platform/exported/mediastream/media_stream_audio_processor_options_test.cc

+// Copyright 2019 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 "third_party/blink/public/platform/modules/mediastream/media_stream_audio_processor_options.h"
+
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace blink {
+
+TEST(ConfigAutomaticGainControlTest, EnableDefaultAGC1) {
+  webrtc::AudioProcessing::Config apm_config;
+  ConfigAutomaticGainControl(&apm_config,
+                             true,   // |agc_enabled|.
+                             false,  // |experimental_agc_enabled|.
+                             false,  // |use_hybrid_agc|.
+                             base::nullopt, base::nullopt, base::nullopt);
+  EXPECT_TRUE(apm_config.gain_controller1.enabled);
+  EXPECT_EQ(
+      apm_config.gain_controller1.mode,
+#if defined(OS_ANDROID)
+      webrtc::AudioProcessing::Config::GainController1::Mode::kFixedDigital);
+#else
+      webrtc::AudioProcessing::Config::GainController1::Mode::kAdaptiveAnalog);
+#endif  // defined(OS_ANDROID)
+}
+
+TEST(ConfigAutomaticGainControlTest, EnableFixedDigitalAGC1) {
+  webrtc::AudioProcessing::Config apm_config;
+  const double compression_gain_db = 10.0;
+  ConfigAutomaticGainControl(&apm_config,
+                             true,   // |agc_enabled|.
+                             false,  // |experimental_agc_enabled|.
+                             false,  // |use_hybrid_agc|.
+                             base::nullopt, base::nullopt, compression_gain_db);
+  EXPECT_TRUE(apm_config.gain_controller1.enabled);
+  EXPECT_EQ(
+      apm_config.gain_controller1.mode,
+      webrtc::AudioProcessing::Config::GainController1::Mode::kFixedDigital);
+  EXPECT_FLOAT_EQ(apm_config.gain_controller1.compression_gain_db,
+                  compression_gain_db);
+}
+
+TEST(ConfigAutomaticGainControlTest, ConfigAGC2ForHybridAGC) {
+  webrtc::AudioProcessing::Config apm_config;
+  const bool use_peaks_not_rms = true;
+  const int saturation_margin = 10;
+  ConfigAutomaticGainControl(&apm_config,
+                             true,  // |agc_enabled|.
+                             true,  // |experimental_agc_enabled|.
+                             true,  // |use_hybrid_agc|.
+                             use_peaks_not_rms, saturation_margin,
+                             base::nullopt);
+  EXPECT_TRUE(apm_config.gain_controller2.enabled);
+  EXPECT_EQ(apm_config.gain_controller2.fixed_digital.gain_db, 0);
+  EXPECT_TRUE(apm_config.gain_controller2.adaptive_digital.enabled);
+  EXPECT_EQ(
+      apm_config.gain_controller2.adaptive_digital.level_estimator,
+      webrtc::AudioProcessing::Config::GainController2::LevelEstimator::kPeak);
+  EXPECT_EQ(
+      apm_config.gain_controller2.adaptive_digital.extra_saturation_margin_db,
+      saturation_margin);
+}
+
+}  // namespace blink