Remove unused code in APM

- The injection of the AGC2 level estimator into `AgcManagerDirect`
  is not used anymore
- `ExperimentalAgc::enabled_agc2_level_estimator` can also be removed
- 3 ctors of `ExperimentalAgc` are unused
- `AgcManagerDirectStandaloneTest::AgcMinMicLevelExperiment` can be
  split into separate unit tests (better code clarity)

Bug: webrtc:7494
Change-Id: I5843147c38cf7cb5ee484b0a72fe13dcf363efaf
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/202025
Commit-Queue: Alessio Bazzica <alessiob@webrtc.org>
Reviewed-by: Per Åhgren <peah@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33027}

modules/audio_processing/agc/BUILD.gn

@@ -33,7 +33,6 @@ rtc_library("agc") {
     "../../../rtc_base:safe_minmax",
     "../../../system_wrappers:field_trial",
     "../../../system_wrappers:metrics",
-    "../agc2:level_estimation_agc",
     "../vad",
   ]
   absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]

modules/audio_processing/agc/agc_manager_direct.cc

@@ -16,7 +16,6 @@
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/agc/gain_control.h"
 #include "modules/audio_processing/agc/gain_map_internal.h"
-#include "modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h"
 #include "rtc_base/atomic_ops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -138,24 +137,18 @@ float ComputeClippedRatio(const float* const* audio,
 MonoAgc::MonoAgc(ApmDataDumper* data_dumper,
                  int startup_min_level,
                  int clipped_level_min,
-                 bool use_agc2_level_estimation,
                  bool disable_digital_adaptive,
                  int min_mic_level)
     : min_mic_level_(min_mic_level),
       disable_digital_adaptive_(disable_digital_adaptive),
+      agc_(std::make_unique<Agc>()),
       max_level_(kMaxMicLevel),
       max_compression_gain_(kMaxCompressionGain),
       target_compression_(kDefaultCompressionGain),
       compression_(target_compression_),
       compression_accumulator_(compression_),
       startup_min_level_(ClampLevel(startup_min_level, min_mic_level_)),
-      clipped_level_min_(clipped_level_min) {
+      clipped_level_min_(clipped_level_min) {}
-  if (use_agc2_level_estimation) {
-    agc_ = std::make_unique<AdaptiveModeLevelEstimatorAgc>(data_dumper);
-  } else {
-    agc_ = std::make_unique<Agc>();
-  }
-}
 
 MonoAgc::~MonoAgc() = default;
 
@@ -415,7 +408,6 @@ AgcManagerDirect::AgcManagerDirect(Agc* agc,
     : AgcManagerDirect(/*num_capture_channels*/ 1,
                        startup_min_level,
                        clipped_level_min,
-                       /*use_agc2_level_estimation*/ false,
                        /*disable_digital_adaptive*/ false,
                        sample_rate_hz) {
   RTC_DCHECK(channel_agcs_[0]);
@@ -426,7 +418,6 @@ AgcManagerDirect::AgcManagerDirect(Agc* agc,
 AgcManagerDirect::AgcManagerDirect(int num_capture_channels,
                                    int startup_min_level,
                                    int clipped_level_min,
-                                   bool use_agc2_level_estimation,
                                    bool disable_digital_adaptive,
                                    int sample_rate_hz)
     : data_dumper_(
@@ -445,7 +436,7 @@ AgcManagerDirect::AgcManagerDirect(int num_capture_channels,
 
     channel_agcs_[ch] = std::make_unique<MonoAgc>(
         data_dumper_ch, startup_min_level, clipped_level_min,
-        use_agc2_level_estimation, disable_digital_adaptive_, min_mic_level);
+        disable_digital_adaptive_, min_mic_level);
   }
   RTC_DCHECK_LT(0, channel_agcs_.size());
   channel_agcs_[0]->ActivateLogging();

modules/audio_processing/agc/agc_manager_direct.h

@@ -38,7 +38,6 @@ class AgcManagerDirect final {
   AgcManagerDirect(int num_capture_channels,
                    int startup_min_level,
                    int clipped_level_min,
-                   bool use_agc2_level_estimation,
                    bool disable_digital_adaptive,
                    int sample_rate_hz);
 
@@ -73,6 +72,16 @@ class AgcManagerDirect final {
                            DisableDigitalDisablesDigital);
   FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
                            AgcMinMicLevelExperiment);
+  FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
+                           AgcMinMicLevelExperimentDisabled);
+  FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
+                           AgcMinMicLevelExperimentOutOfRangeAbove);
+  FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
+                           AgcMinMicLevelExperimentOutOfRangeBelow);
+  FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
+                           AgcMinMicLevelExperimentEnabled50);
+  FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
+                           AgcMinMicLevelExperimentEnabledAboveStartupLevel);
 
   // Dependency injection for testing. Don't delete |agc| as the memory is owned
   // by the manager.
@@ -106,7 +115,6 @@ class MonoAgc {
   MonoAgc(ApmDataDumper* data_dumper,
           int startup_min_level,
           int clipped_level_min,
-          bool use_agc2_level_estimation,
           bool disable_digital_adaptive,
           int min_mic_level);
   ~MonoAgc();

modules/audio_processing/agc/agc_manager_direct_unittest.cc

@@ -56,6 +56,13 @@ class MockGainControl : public GainControl {
   MOCK_METHOD(bool, stream_is_saturated, (), (const, override));
 };
 
+std::unique_ptr<AgcManagerDirect> CreateAgcManagerDirect(
+    int startup_min_level) {
+  return std::make_unique<AgcManagerDirect>(
+      /*num_capture_channels=*/1, startup_min_level, kClippedMin,
+      /*disable_digital_adaptive=*/true, kSampleRateHz);
+}
+
 }  // namespace
 
 class AgcManagerDirectTest : public ::testing::Test {
@@ -692,77 +699,78 @@ TEST_F(AgcManagerDirectTest, TakesNoActionOnZeroMicVolume) {
 TEST(AgcManagerDirectStandaloneTest, DisableDigitalDisablesDigital) {
   auto agc = std::unique_ptr<Agc>(new ::testing::NiceMock<MockAgc>());
   MockGainControl gctrl;
-  AgcManagerDirect manager(/* num_capture_channels */ 1, kInitialVolume,
-                           kClippedMin,
-                           /* use agc2 level estimation */ false,
-                           /* disable digital adaptive */ true, kSampleRateHz);
-
   EXPECT_CALL(gctrl, set_mode(GainControl::kFixedDigital));
   EXPECT_CALL(gctrl, set_target_level_dbfs(0));
   EXPECT_CALL(gctrl, set_compression_gain_db(0));
   EXPECT_CALL(gctrl, enable_limiter(false));
 
-  manager.Initialize();
+  std::unique_ptr<AgcManagerDirect> manager =
-  manager.SetupDigitalGainControl(&gctrl);
+      CreateAgcManagerDirect(kInitialVolume);
+  manager->Initialize();
+  manager->SetupDigitalGainControl(&gctrl);
 }
 
 TEST(AgcManagerDirectStandaloneTest, AgcMinMicLevelExperiment) {
-  auto agc_man = std::unique_ptr<AgcManagerDirect>(new AgcManagerDirect(
+  std::unique_ptr<AgcManagerDirect> manager =
-      /* num_capture_channels */ 1, kInitialVolume, kClippedMin, true, true,
+      CreateAgcManagerDirect(kInitialVolume);
-      kSampleRateHz));
+  EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
-  EXPECT_EQ(agc_man->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
+  EXPECT_EQ(manager->channel_agcs_[0]->startup_min_level(), kInitialVolume);
-  EXPECT_EQ(agc_man->channel_agcs_[0]->startup_min_level(), kInitialVolume);
+}
-  {
+
+TEST(AgcManagerDirectStandaloneTest, AgcMinMicLevelExperimentDisabled) {
   test::ScopedFieldTrials field_trial(
       "WebRTC-Audio-AgcMinMicLevelExperiment/Disabled/");
-    agc_man.reset(new AgcManagerDirect(
+  std::unique_ptr<AgcManagerDirect> manager =
-        /* num_capture_channels */ 1, kInitialVolume, kClippedMin, true, true,
+      CreateAgcManagerDirect(kInitialVolume);
-        kSampleRateHz));
+  EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
+  EXPECT_EQ(manager->channel_agcs_[0]->startup_min_level(), kInitialVolume);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->startup_min_level(), kInitialVolume);
 }
-  {
+
-    // Valid range of field-trial parameter is [0,255].
+// Checks that a field-trial parameter outside of the valid range [0,255] is
+// ignored.
+TEST(AgcManagerDirectStandaloneTest, AgcMinMicLevelExperimentOutOfRangeAbove) {
   test::ScopedFieldTrials field_trial(
       "WebRTC-Audio-AgcMinMicLevelExperiment/Enabled-256/");
-    agc_man.reset(new AgcManagerDirect(
+  std::unique_ptr<AgcManagerDirect> manager =
-        /* num_capture_channels */ 1, kInitialVolume, kClippedMin, true, true,
+      CreateAgcManagerDirect(kInitialVolume);
-        kSampleRateHz));
+  EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
+  EXPECT_EQ(manager->channel_agcs_[0]->startup_min_level(), kInitialVolume);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->startup_min_level(), kInitialVolume);
 }
-  {
+
+// Checks that a field-trial parameter outside of the valid range [0,255] is
+// ignored.
+TEST(AgcManagerDirectStandaloneTest, AgcMinMicLevelExperimentOutOfRangeBelow) {
   test::ScopedFieldTrials field_trial(
       "WebRTC-Audio-AgcMinMicLevelExperiment/Enabled--1/");
-    agc_man.reset(new AgcManagerDirect(
+  std::unique_ptr<AgcManagerDirect> manager =
-        /* num_capture_channels */ 1, kInitialVolume, kClippedMin, true, true,
+      CreateAgcManagerDirect(kInitialVolume);
-        kSampleRateHz));
+  EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->min_mic_level(), kMinMicLevel);
+  EXPECT_EQ(manager->channel_agcs_[0]->startup_min_level(), kInitialVolume);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->startup_min_level(), kInitialVolume);
 }
-  {
+
-    // Verify that a valid experiment changes the minimum microphone level.
+// Verifies that a valid experiment changes the minimum microphone level. The
-    // The start volume is larger than the min level and should therefore not
+// start volume is larger than the min level and should therefore not be
-    // be changed.
+// changed.
+TEST(AgcManagerDirectStandaloneTest, AgcMinMicLevelExperimentEnabled50) {
   test::ScopedFieldTrials field_trial(
       "WebRTC-Audio-AgcMinMicLevelExperiment/Enabled-50/");
-    agc_man.reset(new AgcManagerDirect(
+  std::unique_ptr<AgcManagerDirect> manager =
-        /* num_capture_channels */ 1, kInitialVolume, kClippedMin, true, true,
+      CreateAgcManagerDirect(kInitialVolume);
-        kSampleRateHz));
+  EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), 50);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->min_mic_level(), 50);
+  EXPECT_EQ(manager->channel_agcs_[0]->startup_min_level(), kInitialVolume);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->startup_min_level(), kInitialVolume);
 }
-  {
+
-    // Use experiment to reduce the default minimum microphone level, start at
+// Uses experiment to reduce the default minimum microphone level, start at a
-    // a lower level and ensure that the startup level is increased to the min
+// lower level and ensure that the startup level is increased to the min level
-    // level set by the experiment.
+// set by the experiment.
+TEST(AgcManagerDirectStandaloneTest,
+     AgcMinMicLevelExperimentEnabledAboveStartupLevel) {
   test::ScopedFieldTrials field_trial(
       "WebRTC-Audio-AgcMinMicLevelExperiment/Enabled-50/");
-    agc_man.reset(new AgcManagerDirect(/* num_capture_channels */ 1, 30,
+  std::unique_ptr<AgcManagerDirect> manager =
-                                       kClippedMin, true, true, kSampleRateHz));
+      CreateAgcManagerDirect(/*startup_min_level=*/30);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->min_mic_level(), 50);
+  EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), 50);
-    EXPECT_EQ(agc_man->channel_agcs_[0]->startup_min_level(), 50);
+  EXPECT_EQ(manager->channel_agcs_[0]->startup_min_level(), 50);
-  }
 }
 
 }  // namespace webrtc

modules/audio_processing/agc2/BUILD.gn

@@ -15,31 +15,6 @@ group("agc2") {
   ]
 }
 
-rtc_library("level_estimation_agc") {
-  sources = [
-    "adaptive_mode_level_estimator_agc.cc",
-    "adaptive_mode_level_estimator_agc.h",
-  ]
-  configs += [ "..:apm_debug_dump" ]
-  deps = [
-    ":adaptive_digital",
-    ":common",
-    ":gain_applier",
-    ":noise_level_estimator",
-    ":rnn_vad_with_level",
-    "..:api",
-    "..:apm_logging",
-    "..:audio_frame_view",
-    "../../../api:array_view",
-    "../../../common_audio",
-    "../../../rtc_base:checks",
-    "../../../rtc_base:rtc_base_approved",
-    "../../../rtc_base:safe_minmax",
-    "../agc:level_estimation",
-    "../vad",
-  ]
-}
-
 rtc_library("adaptive_digital") {
   sources = [
     "adaptive_agc.cc",

modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.cc

@@ -1,65 +0,0 @@
-/*
- *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h"
-
-#include <cmath>
-#include <vector>
-
-#include "modules/audio_processing/agc2/agc2_common.h"
-#include "modules/audio_processing/include/audio_frame_view.h"
-
-namespace webrtc {
-
-AdaptiveModeLevelEstimatorAgc::AdaptiveModeLevelEstimatorAgc(
-    ApmDataDumper* apm_data_dumper)
-    : level_estimator_(apm_data_dumper) {
-  set_target_level_dbfs(kDefaultAgc2LevelHeadroomDbfs);
-}
-
-// |audio| must be mono; in a multi-channel stream, provide the first (usually
-// left) channel.
-void AdaptiveModeLevelEstimatorAgc::Process(const int16_t* audio,
-                                            size_t length,
-                                            int sample_rate_hz) {
-  std::vector<float> float_audio_frame(audio, audio + length);
-  const float* const first_channel = &float_audio_frame[0];
-  AudioFrameView<const float> frame_view(&first_channel, 1 /* num channels */,
-                                         length);
-  const auto vad_prob = agc2_vad_.AnalyzeFrame(frame_view);
-  latest_voice_probability_ = vad_prob.speech_probability;
-  if (latest_voice_probability_ > kVadConfidenceThreshold) {
-    time_in_ms_since_last_estimate_ += kFrameDurationMs;
-  }
-  level_estimator_.Update(vad_prob);
-}
-
-// Retrieves the difference between the target RMS level and the current
-// signal RMS level in dB. Returns true if an update is available and false
-// otherwise, in which case |error| should be ignored and no action taken.
-bool AdaptiveModeLevelEstimatorAgc::GetRmsErrorDb(int* error) {
-  if (time_in_ms_since_last_estimate_ <= kTimeUntilConfidentMs) {
-    return false;
-  }
-  *error =
-      std::floor(target_level_dbfs() - level_estimator_.level_dbfs() + 0.5f);
-  time_in_ms_since_last_estimate_ = 0;
-  return true;
-}
-
-void AdaptiveModeLevelEstimatorAgc::Reset() {
-  level_estimator_.Reset();
-}
-
-float AdaptiveModeLevelEstimatorAgc::voice_probability() const {
-  return latest_voice_probability_;
-}
-
-}  // namespace webrtc

modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h

@@ -1,51 +0,0 @@
-/*
- *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_AGC_H_
-#define MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_AGC_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "modules/audio_processing/agc/agc.h"
-#include "modules/audio_processing/agc2/adaptive_mode_level_estimator.h"
-#include "modules/audio_processing/agc2/saturation_protector.h"
-#include "modules/audio_processing/agc2/vad_with_level.h"
-
-namespace webrtc {
-class AdaptiveModeLevelEstimatorAgc : public Agc {
- public:
-  explicit AdaptiveModeLevelEstimatorAgc(ApmDataDumper* apm_data_dumper);
-
-  // |audio| must be mono; in a multi-channel stream, provide the first (usually
-  // left) channel.
-  void Process(const int16_t* audio,
-               size_t length,
-               int sample_rate_hz) override;
-
-  // Retrieves the difference between the target RMS level and the current
-  // signal RMS level in dB. Returns true if an update is available and false
-  // otherwise, in which case |error| should be ignored and no action taken.
-  bool GetRmsErrorDb(int* error) override;
-  void Reset() override;
-
-  float voice_probability() const override;
-
- private:
-  static constexpr int kTimeUntilConfidentMs = 700;
-  static constexpr int kDefaultAgc2LevelHeadroomDbfs = -1;
-  int32_t time_in_ms_since_last_estimate_ = 0;
-  AdaptiveModeLevelEstimator level_estimator_;
-  VadLevelAnalyzer agc2_vad_;
-  float latest_voice_probability_ = 0.f;
-};
-}  // namespace webrtc
-
-#endif  // MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_AGC_H_

modules/audio_processing/audio_processing_impl.cc

@@ -304,8 +304,6 @@ AudioProcessingImpl::AudioProcessingImpl(
       config.Get<ExperimentalAgc>().startup_min_volume;
   config_.gain_controller1.analog_gain_controller.clipped_level_min =
       config.Get<ExperimentalAgc>().clipped_level_min;
-  config_.gain_controller1.analog_gain_controller.enable_agc2_level_estimator =
-      config.Get<ExperimentalAgc>().enabled_agc2_level_estimator;
   config_.gain_controller1.analog_gain_controller.enable_digital_adaptive =
       !config.Get<ExperimentalAgc>().digital_adaptive_disabled;
 #endif
@@ -1782,8 +1780,6 @@ void AudioProcessingImpl::InitializeGainController1() {
         num_proc_channels(),
         config_.gain_controller1.analog_gain_controller.startup_min_volume,
         config_.gain_controller1.analog_gain_controller.clipped_level_min,
-        config_.gain_controller1.analog_gain_controller
-            .enable_agc2_level_estimator,
         !config_.gain_controller1.analog_gain_controller
              .enable_digital_adaptive,
         capture_nonlocked_.split_rate));

modules/audio_processing/audio_processing_unittest.cc

@@ -2931,10 +2931,6 @@ TEST(AudioProcessing, GainController1ConfigEqual) {
   b_analog.clipped_level_min = a_analog.clipped_level_min;
   EXPECT_EQ(a, b);
 
-  Toggle(a_analog.enable_agc2_level_estimator);
-  b_analog.enable_agc2_level_estimator = a_analog.enable_agc2_level_estimator;
-  EXPECT_EQ(a, b);
-
   Toggle(a_analog.enable_digital_adaptive);
   b_analog.enable_digital_adaptive = a_analog.enable_digital_adaptive;
   EXPECT_EQ(a, b);
@@ -2989,10 +2985,6 @@ TEST(AudioProcessing, GainController1ConfigNotEqual) {
   EXPECT_NE(a, b);
   a_analog.clipped_level_min = b_analog.clipped_level_min;
 
-  Toggle(a_analog.enable_agc2_level_estimator);
-  EXPECT_NE(a, b);
-  a_analog.enable_agc2_level_estimator = b_analog.enable_agc2_level_estimator;
-
   Toggle(a_analog.enable_digital_adaptive);
   EXPECT_NE(a, b);
   a_analog.enable_digital_adaptive = b_analog.enable_digital_adaptive;

modules/audio_processing/include/audio_processing.cc

@@ -87,8 +87,6 @@ bool Agc1Config::operator==(const Agc1Config& rhs) const {
          analog_lhs.enabled == analog_rhs.enabled &&
          analog_lhs.startup_min_volume == analog_rhs.startup_min_volume &&
          analog_lhs.clipped_level_min == analog_rhs.clipped_level_min &&
-         analog_lhs.enable_agc2_level_estimator ==
-             analog_rhs.enable_agc2_level_estimator &&
          analog_lhs.enable_digital_adaptive ==
              analog_rhs.enable_digital_adaptive;
 }

modules/audio_processing/include/audio_processing.h

@@ -72,32 +72,13 @@ static constexpr int kClippedLevelMin = 70;
 struct ExperimentalAgc {
   ExperimentalAgc() = default;
   explicit ExperimentalAgc(bool enabled) : enabled(enabled) {}
-  ExperimentalAgc(bool enabled,
-                  bool enabled_agc2_level_estimator,
-                  bool digital_adaptive_disabled)
-      : enabled(enabled),
-        enabled_agc2_level_estimator(enabled_agc2_level_estimator),
-        digital_adaptive_disabled(digital_adaptive_disabled) {}
-  // Deprecated constructor: will be removed.
-  ExperimentalAgc(bool enabled,
-                  bool enabled_agc2_level_estimator,
-                  bool digital_adaptive_disabled,
-                  bool analyze_before_aec)
-      : enabled(enabled),
-        enabled_agc2_level_estimator(enabled_agc2_level_estimator),
-        digital_adaptive_disabled(digital_adaptive_disabled) {}
   ExperimentalAgc(bool enabled, int startup_min_volume)
       : enabled(enabled), startup_min_volume(startup_min_volume) {}
-  ExperimentalAgc(bool enabled, int startup_min_volume, int clipped_level_min)
-      : enabled(enabled),
-        startup_min_volume(startup_min_volume),
-        clipped_level_min(clipped_level_min) {}
   static const ConfigOptionID identifier = ConfigOptionID::kExperimentalAgc;
   bool enabled = true;
   int startup_min_volume = kAgcStartupMinVolume;
   // Lowest microphone level that will be applied in response to clipping.
   int clipped_level_min = kClippedLevelMin;
-  bool enabled_agc2_level_estimator = false;
   bool digital_adaptive_disabled = false;
 };
 
@@ -331,7 +312,6 @@ class RTC_EXPORT AudioProcessing : public rtc::RefCountInterface {
         // Lowest analog microphone level that will be applied in response to
         // clipping.
         int clipped_level_min = kClippedLevelMin;
-        bool enable_agc2_level_estimator = false;
         bool enable_digital_adaptive = true;
       } analog_gain_controller;
     } gain_controller1;

modules/audio_processing/test/audio_processing_simulator.cc

@@ -497,11 +497,6 @@ void AudioProcessingSimulator::ConfigureAudioProcessor() {
     apm_config.gain_controller1.analog_gain_controller.enabled =
         *settings_.use_analog_agc;
   }
-  if (settings_.use_analog_agc_agc2_level_estimator) {
-    apm_config.gain_controller1.analog_gain_controller
-        .enable_agc2_level_estimator =
-        *settings_.use_analog_agc_agc2_level_estimator;
-  }
   if (settings_.analog_agc_disable_digital_adaptive) {
     apm_config.gain_controller1.analog_gain_controller.enable_digital_adaptive =
         *settings_.analog_agc_disable_digital_adaptive;

modules/audio_processing/test/audio_processing_simulator.h

@@ -106,7 +106,6 @@ struct SimulationSettings {
   absl::optional<bool> use_vad;
   absl::optional<bool> use_le;
   absl::optional<bool> use_all;
-  absl::optional<bool> use_analog_agc_agc2_level_estimator;
   absl::optional<bool> analog_agc_disable_digital_adaptive;
   absl::optional<int> agc_mode;
   absl::optional<int> agc_target_level;

modules/audio_processing/test/audioproc_float_impl.cc

@@ -124,11 +124,6 @@ ABSL_FLAG(int,
           kParameterNotSpecifiedValue,
           "Force-deactivate (1) digital adaptation in "
           "experimental AGC. Digital adaptation is active by default (0).");
-ABSL_FLAG(int,
-          analog_agc_agc2_level_estimator,
-          kParameterNotSpecifiedValue,
-          "AGC2 level estimation"
-          " in the experimental AGC. AGC1 level estimation is the default (0)");
 ABSL_FLAG(int,
           agc_mode,
           kParameterNotSpecifiedValue,
@@ -387,8 +382,6 @@ SimulationSettings CreateSettings() {
   SetSettingIfFlagSet(absl::GetFlag(FLAGS_le), &settings.use_le);
   SetSettingIfFlagSet(absl::GetFlag(FLAGS_analog_agc_disable_digital_adaptive),
                       &settings.analog_agc_disable_digital_adaptive);
-  SetSettingIfFlagSet(absl::GetFlag(FLAGS_analog_agc_agc2_level_estimator),
-                      &settings.use_analog_agc_agc2_level_estimator);
   SetSettingIfSpecified(absl::GetFlag(FLAGS_agc_mode), &settings.agc_mode);
   SetSettingIfSpecified(absl::GetFlag(FLAGS_agc_target_level),
                         &settings.agc_target_level);