diff --git a/modules/audio_processing/agc2/BUILD.gn b/modules/audio_processing/agc2/BUILD.gn
index 910b58c..4c6cfab 100644
--- a/modules/audio_processing/agc2/BUILD.gn
+++ b/modules/audio_processing/agc2/BUILD.gn
@@ -25,6 +25,8 @@
     "adaptive_mode_level_estimator.h",
     "saturation_protector.cc",
     "saturation_protector.h",
+    "saturation_protector_buffer.cc",
+    "saturation_protector_buffer.h",
   ]
 
   configs += [ "..:apm_debug_dump" ]
@@ -177,6 +179,7 @@
     "adaptive_digital_gain_applier_unittest.cc",
     "adaptive_mode_level_estimator_unittest.cc",
     "gain_applier_unittest.cc",
+    "saturation_protector_buffer_unittest.cc",
     "saturation_protector_unittest.cc",
   ]
   deps = [
diff --git a/modules/audio_processing/agc2/adaptive_agc.cc b/modules/audio_processing/agc2/adaptive_agc.cc
index 37f11d2..8bf192e 100644
--- a/modules/audio_processing/agc2/adaptive_agc.cc
+++ b/modules/audio_processing/agc2/adaptive_agc.cc
@@ -25,15 +25,6 @@
 using NoiseEstimatorType =
     AudioProcessing::Config::GainController2::NoiseEstimator;
 
-void DumpDebugData(const AdaptiveDigitalGainApplier::FrameInfo& info,
-                   ApmDataDumper& dumper) {
-  dumper.DumpRaw("agc2_vad_probability", info.vad_result.speech_probability);
-  dumper.DumpRaw("agc2_vad_rms_dbfs", info.vad_result.rms_dbfs);
-  dumper.DumpRaw("agc2_vad_peak_dbfs", info.vad_result.peak_dbfs);
-  dumper.DumpRaw("agc2_noise_estimate_dbfs", info.input_noise_level_dbfs);
-  dumper.DumpRaw("agc2_last_limiter_audio_level", info.limiter_envelope_dbfs);
-}
-
 constexpr int kGainApplierAdjacentSpeechFramesThreshold = 1;
 constexpr float kMaxGainChangePerSecondDb = 3.0f;
 constexpr float kMaxOutputNoiseLevelDbfs = -50.0f;
@@ -72,36 +63,42 @@
 
 AdaptiveAgc::AdaptiveAgc(ApmDataDumper* apm_data_dumper)
     : speech_level_estimator_(apm_data_dumper),
-      gain_applier_(apm_data_dumper,
-                    kGainApplierAdjacentSpeechFramesThreshold,
-                    kMaxGainChangePerSecondDb,
-                    kMaxOutputNoiseLevelDbfs),
+      gain_controller_(apm_data_dumper,
+                       kGainApplierAdjacentSpeechFramesThreshold,
+                       kMaxGainChangePerSecondDb,
+                       kMaxOutputNoiseLevelDbfs),
       apm_data_dumper_(apm_data_dumper),
       noise_level_estimator_(
           CreateNoiseLevelEstimator(kDefaultNoiseLevelEstimatorType,
+                                    apm_data_dumper)),
+      saturation_protector_(
+          CreateSaturationProtector(kSaturationProtectorInitialHeadroomDb,
+                                    kSaturationProtectorExtraHeadroomDb,
+                                    kGainApplierAdjacentSpeechFramesThreshold,
                                     apm_data_dumper)) {
   RTC_DCHECK(apm_data_dumper);
 }
 
 AdaptiveAgc::AdaptiveAgc(ApmDataDumper* apm_data_dumper,
                          const AdaptiveDigitalConfig& config)
-    : speech_level_estimator_(
-          apm_data_dumper,
-          config.level_estimator,
-          config.level_estimator_adjacent_speech_frames_threshold,
-          config.initial_saturation_margin_db,
-          config.extra_saturation_margin_db),
-      vad_(config.vad_reset_period_ms,
-           config.vad_probability_attack,
-           GetAllowedCpuFeatures(config)),
-      gain_applier_(apm_data_dumper,
-                    config.gain_applier_adjacent_speech_frames_threshold,
-                    config.max_gain_change_db_per_second,
-                    config.max_output_noise_level_dbfs),
+    : speech_level_estimator_(apm_data_dumper,
+                              config.adjacent_speech_frames_threshold),
+      vad_(config.vad_reset_period_ms, GetAllowedCpuFeatures(config)),
+      gain_controller_(apm_data_dumper,
+                       config.adjacent_speech_frames_threshold,
+                       config.max_gain_change_db_per_second,
+                       config.max_output_noise_level_dbfs),
       apm_data_dumper_(apm_data_dumper),
       noise_level_estimator_(
-          CreateNoiseLevelEstimator(config.noise_estimator, apm_data_dumper)) {
+          CreateNoiseLevelEstimator(config.noise_estimator, apm_data_dumper)),
+      saturation_protector_(
+          CreateSaturationProtector(kSaturationProtectorInitialHeadroomDb,
+                                    kSaturationProtectorExtraHeadroomDb,
+                                    config.adjacent_speech_frames_threshold,
+                                    apm_data_dumper)) {
   RTC_DCHECK(apm_data_dumper);
+  RTC_DCHECK(noise_level_estimator_);
+  RTC_DCHECK(saturation_protector_);
   if (!config.use_saturation_protector) {
     RTC_LOG(LS_WARNING) << "The saturation protector cannot be disabled.";
   }
@@ -111,19 +108,39 @@
 
 void AdaptiveAgc::Process(AudioFrameView<float> frame, float limiter_envelope) {
   AdaptiveDigitalGainApplier::FrameInfo info;
-  info.vad_result = vad_.AnalyzeFrame(frame);
-  speech_level_estimator_.Update(info.vad_result);
-  info.input_level_dbfs = speech_level_estimator_.level_dbfs();
-  info.input_noise_level_dbfs = noise_level_estimator_->Analyze(frame);
-  info.limiter_envelope_dbfs =
-      limiter_envelope > 0 ? FloatS16ToDbfs(limiter_envelope) : -90.0f;
-  info.estimate_is_confident = speech_level_estimator_.IsConfident();
-  DumpDebugData(info, *apm_data_dumper_);
-  gain_applier_.Process(info, frame);
+
+  VadLevelAnalyzer::Result vad_result = vad_.AnalyzeFrame(frame);
+  info.speech_probability = vad_result.speech_probability;
+  apm_data_dumper_->DumpRaw("agc2_speech_probability",
+                            vad_result.speech_probability);
+  apm_data_dumper_->DumpRaw("agc2_input_rms_dbfs", vad_result.rms_dbfs);
+  apm_data_dumper_->DumpRaw("agc2_input_peak_dbfs", vad_result.peak_dbfs);
+
+  speech_level_estimator_.Update(vad_result);
+  info.speech_level_dbfs = speech_level_estimator_.level_dbfs();
+  info.speech_level_reliable = speech_level_estimator_.IsConfident();
+  apm_data_dumper_->DumpRaw("agc2_speech_level_dbfs", info.speech_level_dbfs);
+  apm_data_dumper_->DumpRaw("agc2_speech_level_reliable",
+                            info.speech_level_reliable);
+
+  info.noise_rms_dbfs = noise_level_estimator_->Analyze(frame);
+  apm_data_dumper_->DumpRaw("agc2_noise_rms_dbfs", info.noise_rms_dbfs);
+
+  saturation_protector_->Analyze(info.speech_probability, vad_result.peak_dbfs,
+                                 info.speech_level_dbfs);
+  info.headroom_db = saturation_protector_->HeadroomDb();
+  apm_data_dumper_->DumpRaw("agc2_headroom_db", info.headroom_db);
+
+  info.limiter_envelope_dbfs = FloatS16ToDbfs(limiter_envelope);
+  apm_data_dumper_->DumpRaw("agc2_limiter_envelope_dbfs",
+                            info.limiter_envelope_dbfs);
+
+  gain_controller_.Process(info, frame);
 }
 
-void AdaptiveAgc::Reset() {
+void AdaptiveAgc::HandleInputGainChange() {
   speech_level_estimator_.Reset();
+  saturation_protector_->Reset();
 }
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/adaptive_agc.h b/modules/audio_processing/agc2/adaptive_agc.h
index 525cab7..fe81444 100644
--- a/modules/audio_processing/agc2/adaptive_agc.h
+++ b/modules/audio_processing/agc2/adaptive_agc.h
@@ -16,6 +16,7 @@
 #include "modules/audio_processing/agc2/adaptive_digital_gain_applier.h"
 #include "modules/audio_processing/agc2/adaptive_mode_level_estimator.h"
 #include "modules/audio_processing/agc2/noise_level_estimator.h"
+#include "modules/audio_processing/agc2/saturation_protector.h"
 #include "modules/audio_processing/agc2/vad_with_level.h"
 #include "modules/audio_processing/include/audio_frame_view.h"
 #include "modules/audio_processing/include/audio_processing.h"
@@ -38,14 +39,17 @@
   // account the envelope measured by the limiter.
   // TODO(crbug.com/webrtc/7494): Make the class depend on the limiter.
   void Process(AudioFrameView<float> frame, float limiter_envelope);
-  void Reset();
+
+  // Handles a gain change applied to the input signal (e.g., analog gain).
+  void HandleInputGainChange();
 
  private:
   AdaptiveModeLevelEstimator speech_level_estimator_;
   VadLevelAnalyzer vad_;
-  AdaptiveDigitalGainApplier gain_applier_;
+  AdaptiveDigitalGainApplier gain_controller_;
   ApmDataDumper* const apm_data_dumper_;
   std::unique_ptr<NoiseLevelEstimator> noise_level_estimator_;
+  std::unique_ptr<SaturationProtector> saturation_protector_;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc b/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
index 8a56464..8a8a7fd 100644
--- a/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
+++ b/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
@@ -23,6 +23,9 @@
 namespace webrtc {
 namespace {
 
+constexpr int kHeadroomHistogramMin = 0;
+constexpr int kHeadroomHistogramMax = 50;
+
 // This function maps input level to desired applied gain. We want to
 // boost the signal so that peaks are at -kHeadroomDbfs. We can't
 // apply more than kMaxGainDb gain.
@@ -31,17 +34,13 @@
   if (input_level_dbfs < -(kHeadroomDbfs + kMaxGainDb)) {
     return kMaxGainDb;
   }
-
   // We expect to end up here most of the time: the level is below
   // -headroom, but we can boost it to -headroom.
   if (input_level_dbfs < -kHeadroomDbfs) {
     return -kHeadroomDbfs - input_level_dbfs;
   }
-
-  // Otherwise, the level is too high and we can't boost. The
-  // LevelEstimator is responsible for not reporting bogus gain
-  // values.
-  RTC_DCHECK_LE(input_level_dbfs, 0.f);
+  // Otherwise, the level is too high and we can't boost.
+  RTC_DCHECK_GE(input_level_dbfs, -kHeadroomDbfs);
   return 0.f;
 }
 
@@ -52,10 +51,11 @@
                        float input_noise_level_dbfs,
                        float max_output_noise_level_dbfs,
                        ApmDataDumper& apm_data_dumper) {
-  const float noise_headroom_db =
+  const float max_allowed_gain_db =
       max_output_noise_level_dbfs - input_noise_level_dbfs;
-  apm_data_dumper.DumpRaw("agc2_noise_headroom_db", noise_headroom_db);
-  return std::min(target_gain, std::max(noise_headroom_db, 0.f));
+  apm_data_dumper.DumpRaw("agc2_adaptive_gain_applier_max_allowed_gain_db",
+                          max_allowed_gain_db);
+  return std::min(target_gain, std::max(max_allowed_gain_db, 0.f));
 }
 
 float LimitGainByLowConfidence(float target_gain,
@@ -68,8 +68,8 @@
   }
   const float limiter_level_before_gain = limiter_audio_level_dbfs - last_gain;
 
-  // Compute a new gain so that limiter_level_before_gain + new_gain <=
-  // kLimiterThreshold.
+  // Compute a new gain so that `limiter_level_before_gain` + `new_target_gain`
+  // is not great than `kLimiterThresholdForAgcGainDbfs`.
   const float new_target_gain = std::max(
       kLimiterThresholdForAgcGainDbfs - limiter_level_before_gain, 0.f);
   return std::min(new_target_gain, target_gain);
@@ -80,13 +80,16 @@
 float ComputeGainChangeThisFrameDb(float target_gain_db,
                                    float last_gain_db,
                                    bool gain_increase_allowed,
-                                   float max_gain_change_db) {
+                                   float max_gain_decrease_db,
+                                   float max_gain_increase_db) {
+  RTC_DCHECK_GT(max_gain_decrease_db, 0);
+  RTC_DCHECK_GT(max_gain_increase_db, 0);
   float target_gain_difference_db = target_gain_db - last_gain_db;
   if (!gain_increase_allowed) {
     target_gain_difference_db = std::min(target_gain_difference_db, 0.f);
   }
-  return rtc::SafeClamp(target_gain_difference_db, -max_gain_change_db,
-                        max_gain_change_db);
+  return rtc::SafeClamp(target_gain_difference_db, -max_gain_decrease_db,
+                        max_gain_increase_db);
 }
 
 }  // namespace
@@ -115,7 +118,7 @@
 
 void AdaptiveDigitalGainApplier::Process(const FrameInfo& info,
                                          AudioFrameView<float> frame) {
-  RTC_DCHECK_GE(info.input_level_dbfs, -150.f);
+  RTC_DCHECK_GE(info.speech_level_dbfs, -150.f);
   RTC_DCHECK_GE(frame.num_channels(), 1);
   RTC_DCHECK(
       frame.samples_per_channel() == 80 || frame.samples_per_channel() == 160 ||
@@ -123,30 +126,46 @@
       << "`frame` does not look like a 10 ms frame for an APM supported sample "
          "rate";
 
+  // Compute the input level used to select the desired gain.
+  RTC_DCHECK_GT(info.headroom_db, 0.0f);
+  const float input_level_dbfs = info.speech_level_dbfs + info.headroom_db;
+
   const float target_gain_db = LimitGainByLowConfidence(
-      LimitGainByNoise(ComputeGainDb(std::min(info.input_level_dbfs, 0.f)),
-                       info.input_noise_level_dbfs,
+      LimitGainByNoise(ComputeGainDb(input_level_dbfs), info.noise_rms_dbfs,
                        max_output_noise_level_dbfs_, *apm_data_dumper_),
-      last_gain_db_, info.limiter_envelope_dbfs, info.estimate_is_confident);
+      last_gain_db_, info.limiter_envelope_dbfs, info.speech_level_reliable);
 
   // Forbid increasing the gain until enough adjacent speech frames are
   // observed.
-  if (info.vad_result.speech_probability < kVadConfidenceThreshold) {
+  bool first_confident_speech_frame = false;
+  if (info.speech_probability < kVadConfidenceThreshold) {
     frames_to_gain_increase_allowed_ = adjacent_speech_frames_threshold_;
   } else if (frames_to_gain_increase_allowed_ > 0) {
     frames_to_gain_increase_allowed_--;
+    first_confident_speech_frame = frames_to_gain_increase_allowed_ == 0;
   }
-  apm_data_dumper_->DumpRaw("agc2_frames_to_gain_increase_allowed",
-                            frames_to_gain_increase_allowed_);
+  apm_data_dumper_->DumpRaw(
+      "agc2_adaptive_gain_applier_frames_to_gain_increase_allowed",
+      frames_to_gain_increase_allowed_);
+
+  const bool gain_increase_allowed = frames_to_gain_increase_allowed_ == 0;
+
+  float max_gain_increase_db = max_gain_change_db_per_10ms_;
+  if (first_confident_speech_frame) {
+    // No gain increase happened while waiting for a long enough speech
+    // sequence. Therefore, temporarily allow a faster gain increase.
+    RTC_DCHECK(gain_increase_allowed);
+    max_gain_increase_db *= adjacent_speech_frames_threshold_;
+  }
 
   const float gain_change_this_frame_db = ComputeGainChangeThisFrameDb(
-      target_gain_db, last_gain_db_,
-      /*gain_increase_allowed=*/frames_to_gain_increase_allowed_ == 0,
-      max_gain_change_db_per_10ms_);
+      target_gain_db, last_gain_db_, gain_increase_allowed,
+      /*max_gain_decrease_db=*/max_gain_change_db_per_10ms_,
+      max_gain_increase_db);
 
-  apm_data_dumper_->DumpRaw("agc2_want_to_change_by_db",
+  apm_data_dumper_->DumpRaw("agc2_adaptive_gain_applier_want_to_change_by_db",
                             target_gain_db - last_gain_db_);
-  apm_data_dumper_->DumpRaw("agc2_will_change_by_db",
+  apm_data_dumper_->DumpRaw("agc2_adaptive_gain_applier_will_change_by_db",
                             gain_change_this_frame_db);
 
   // Optimization: avoid calling math functions if gain does not
@@ -159,23 +178,29 @@
 
   // Remember that the gain has changed for the next iteration.
   last_gain_db_ = last_gain_db_ + gain_change_this_frame_db;
-  apm_data_dumper_->DumpRaw("agc2_applied_gain_db", last_gain_db_);
+  apm_data_dumper_->DumpRaw("agc2_adaptive_gain_applier_applied_gain_db",
+                            last_gain_db_);
 
   // Log every 10 seconds.
   calls_since_last_gain_log_++;
   if (calls_since_last_gain_log_ == 1000) {
     calls_since_last_gain_log_ = 0;
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc2.EstimatedSpeechLevel",
+                                -info.speech_level_dbfs, 0, 100, 101);
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc2.EstimatedNoiseLevel",
+                                -info.noise_rms_dbfs, 0, 100, 101);
+    RTC_HISTOGRAM_COUNTS_LINEAR(
+        "WebRTC.Audio.Agc2.Headroom", info.headroom_db, kHeadroomHistogramMin,
+        kHeadroomHistogramMax,
+        kHeadroomHistogramMax - kHeadroomHistogramMin + 1);
     RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc2.DigitalGainApplied",
                                 last_gain_db_, 0, kMaxGainDb, kMaxGainDb + 1);
-    RTC_HISTOGRAM_COUNTS_LINEAR(
-        "WebRTC.Audio.Agc2.EstimatedSpeechPlusNoiseLevel",
-        -info.input_level_dbfs, 0, 100, 101);
-    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc2.EstimatedNoiseLevel",
-                                -info.input_noise_level_dbfs, 0, 100, 101);
     RTC_LOG(LS_INFO) << "AGC2 adaptive digital"
-                     << " | speech_plus_noise_dbfs: " << info.input_level_dbfs
-                     << " | noise_dbfs: " << info.input_noise_level_dbfs
+                     << " | speech_dbfs: " << info.speech_level_dbfs
+                     << " | noise_dbfs: " << info.noise_rms_dbfs
+                     << " | headroom_db: " << info.headroom_db
                      << " | gain_db: " << last_gain_db_;
   }
 }
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/adaptive_digital_gain_applier.h b/modules/audio_processing/agc2/adaptive_digital_gain_applier.h
index a65379f..74220fa 100644
--- a/modules/audio_processing/agc2/adaptive_digital_gain_applier.h
+++ b/modules/audio_processing/agc2/adaptive_digital_gain_applier.h
@@ -12,33 +12,32 @@
 #define MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_DIGITAL_GAIN_APPLIER_H_
 
 #include "modules/audio_processing/agc2/gain_applier.h"
-#include "modules/audio_processing/agc2/vad_with_level.h"
 #include "modules/audio_processing/include/audio_frame_view.h"
 
 namespace webrtc {
 
 class ApmDataDumper;
 
-// Part of the adaptive digital controller that applies a digital adaptive gain.
-// The gain is updated towards a target. The logic decides when gain updates are
-// allowed, it controls the adaptation speed and caps the target based on the
-// estimated noise level and the speech level estimate confidence.
+// TODO(bugs.webrtc.org): Split into `GainAdaptor` and `GainApplier`.
+// Selects the target digital gain, decides when and how quickly to adapt to the
+// target and applies the current gain to 10 ms frames.
 class AdaptiveDigitalGainApplier {
  public:
   // Information about a frame to process.
   struct FrameInfo {
-    float input_level_dbfs;        // Estimated speech plus noise level.
-    float input_noise_level_dbfs;  // Estimated noise level.
-    VadLevelAnalyzer::Result vad_result;
-    float limiter_envelope_dbfs;  // Envelope level from the limiter.
-    bool estimate_is_confident;
+    float speech_probability;     // Probability of speech in the [0, 1] range.
+    float speech_level_dbfs;      // Estimated speech level (dBFS).
+    bool speech_level_reliable;   // True with reliable speech level estimation.
+    float noise_rms_dbfs;         // Estimated noise RMS level (dBFS).
+    float headroom_db;            // Headroom (dB).
+    float limiter_envelope_dbfs;  // Envelope level from the limiter (dBFS).
   };
 
-  // Ctor.
-  // `adjacent_speech_frames_threshold` indicates how many speech frames are
-  // required before a gain increase is allowed. `max_gain_change_db_per_second`
-  // limits the adaptation speed (uniformly operated across frames).
-  // `max_output_noise_level_dbfs` limits the output noise level.
+  // Ctor. `adjacent_speech_frames_threshold` indicates how many adjacent speech
+  // frames must be observed in order to consider the sequence as speech.
+  // `max_gain_change_db_per_second` limits the adaptation speed (uniformly
+  // operated across frames). `max_output_noise_level_dbfs` limits the output
+  // noise level.
   AdaptiveDigitalGainApplier(ApmDataDumper* apm_data_dumper,
                              int adjacent_speech_frames_threshold,
                              float max_gain_change_db_per_second,
diff --git a/modules/audio_processing/agc2/adaptive_digital_gain_applier_unittest.cc b/modules/audio_processing/agc2/adaptive_digital_gain_applier_unittest.cc
index e2df700..ee9cb02 100644
--- a/modules/audio_processing/agc2/adaptive_digital_gain_applier_unittest.cc
+++ b/modules/audio_processing/agc2/adaptive_digital_gain_applier_unittest.cc
@@ -11,6 +11,7 @@
 #include "modules/audio_processing/agc2/adaptive_digital_gain_applier.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/agc2/agc2_common.h"
@@ -26,104 +27,75 @@
 constexpr int kFrameLen10ms8kHz = 80;
 constexpr int kFrameLen10ms48kHz = 480;
 
+constexpr float kMaxSpeechProbability = 1.0f;
+
 // Constants used in place of estimated noise levels.
-constexpr float kNoNoiseDbfs = -90.f;
+constexpr float kNoNoiseDbfs = kMinLevelDbfs;
 constexpr float kWithNoiseDbfs = -20.f;
-static_assert(std::is_trivially_destructible<VadLevelAnalyzer::Result>::value,
-              "");
-constexpr VadLevelAnalyzer::Result kVadSpeech{1.f, -20.f, 0.f};
 
-constexpr float kMaxGainChangePerSecondDb = 3.f;
+constexpr float kMaxGainChangePerSecondDb = 3.0f;
 constexpr float kMaxGainChangePerFrameDb =
-    kMaxGainChangePerSecondDb * kFrameDurationMs / 1000.f;
-constexpr float kMaxOutputNoiseLevelDbfs = -50.f;
+    kMaxGainChangePerSecondDb * kFrameDurationMs / 1000.0f;
+constexpr float kMaxOutputNoiseLevelDbfs = -50.0f;
 
-// Helper to instance `AdaptiveDigitalGainApplier`.
+// Helper to create initialized `AdaptiveDigitalGainApplier` objects.
 struct GainApplierHelper {
   GainApplierHelper()
       : GainApplierHelper(/*adjacent_speech_frames_threshold=*/1) {}
   explicit GainApplierHelper(int adjacent_speech_frames_threshold)
       : apm_data_dumper(0),
-        gain_applier(&apm_data_dumper,
-                     adjacent_speech_frames_threshold,
-                     kMaxGainChangePerSecondDb,
-                     kMaxOutputNoiseLevelDbfs) {}
+        gain_applier(std::make_unique<AdaptiveDigitalGainApplier>(
+            &apm_data_dumper,
+            adjacent_speech_frames_threshold,
+            kMaxGainChangePerSecondDb,
+            kMaxOutputNoiseLevelDbfs)) {}
   ApmDataDumper apm_data_dumper;
-  AdaptiveDigitalGainApplier gain_applier;
+  std::unique_ptr<AdaptiveDigitalGainApplier> gain_applier;
 };
 
-// Runs gain applier and returns the applied gain in linear scale.
-float RunOnConstantLevel(int num_iterations,
-                         VadLevelAnalyzer::Result vad_level,
-                         float input_level_dbfs,
-                         AdaptiveDigitalGainApplier* gain_applier) {
-  float gain_linear = 0.f;
-
-  for (int i = 0; i < num_iterations; ++i) {
-    VectorFloatFrame fake_audio(kMono, kFrameLen10ms8kHz, 1.f);
-    AdaptiveDigitalGainApplier::FrameInfo info;
-    info.input_level_dbfs = input_level_dbfs;
-    info.input_noise_level_dbfs = kNoNoiseDbfs;
-    info.vad_result = vad_level;
-    info.limiter_envelope_dbfs = -2.f;
-    info.estimate_is_confident = true;
-    gain_applier->Process(info, fake_audio.float_frame_view());
-    gain_linear = fake_audio.float_frame_view().channel(0)[0];
-  }
-  return gain_linear;
-}
-
 // Voice on, no noise, low limiter, confident level.
+static_assert(std::is_trivially_destructible<
+                  AdaptiveDigitalGainApplier::FrameInfo>::value,
+              "");
 constexpr AdaptiveDigitalGainApplier::FrameInfo kFrameInfo{
-    /*input_level_dbfs=*/-1.f,
-    /*input_noise_level_dbfs=*/kNoNoiseDbfs,
-    /*vad_result=*/kVadSpeech,
-    /*limiter_envelope_dbfs=*/-2.f,
-    /*estimate_is_confident=*/true};
+    /*speech_probability=*/kMaxSpeechProbability,
+    /*speech_level_dbfs=*/kInitialSpeechLevelEstimateDbfs,
+    /*speech_level_reliable=*/true,
+    /*noise_rms_dbfs=*/kNoNoiseDbfs,
+    /*headroom_db=*/kSaturationProtectorInitialHeadroomDb,
+    /*limiter_envelope_dbfs=*/-2.0f};
 
-TEST(AutomaticGainController2AdaptiveGainApplier, GainApplierShouldNotCrash) {
+TEST(GainController2AdaptiveGainApplier, GainApplierShouldNotCrash) {
   GainApplierHelper helper;
   // Make one call with reasonable audio level values and settings.
-  VectorFloatFrame fake_audio(kStereo, kFrameLen10ms48kHz, 10000.f);
+  VectorFloatFrame fake_audio(kStereo, kFrameLen10ms48kHz, 10000.0f);
   AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-  info.input_level_dbfs = -5.0;
-  helper.gain_applier.Process(kFrameInfo, fake_audio.float_frame_view());
+  info.speech_level_dbfs = -5.0f;
+  helper.gain_applier->Process(kFrameInfo, fake_audio.float_frame_view());
 }
 
-// Check that the output is -kHeadroom dBFS.
-TEST(AutomaticGainController2AdaptiveGainApplier, TargetLevelIsReached) {
-  GainApplierHelper helper;
-
-  constexpr float initial_level_dbfs = -5.f;
-
-  const float applied_gain = RunOnConstantLevel(
-      200, kVadSpeech, initial_level_dbfs, &helper.gain_applier);
-
-  EXPECT_NEAR(applied_gain, DbToRatio(-kHeadroomDbfs - initial_level_dbfs),
-              0.1f);
-}
-
-// Check that the output is -kHeadroom dBFS
-TEST(AutomaticGainController2AdaptiveGainApplier, GainApproachesMaxGain) {
-  GainApplierHelper helper;
-
-  constexpr float initial_level_dbfs = -kHeadroomDbfs - kMaxGainDb - 10.f;
-  // A few extra frames for safety.
+// Checks that the maximum allowed gain is applied.
+TEST(GainController2AdaptiveGainApplier, MaxGainApplied) {
   constexpr int kNumFramesToAdapt =
       static_cast<int>(kMaxGainDb / kMaxGainChangePerFrameDb) + 10;
 
-  const float applied_gain = RunOnConstantLevel(
-      kNumFramesToAdapt, kVadSpeech, initial_level_dbfs, &helper.gain_applier);
-  EXPECT_NEAR(applied_gain, DbToRatio(kMaxGainDb), 0.1f);
-
-  const float applied_gain_db = 20.f * std::log10(applied_gain);
+  GainApplierHelper helper;
+  AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
+  info.speech_level_dbfs = -60.0f;
+  float applied_gain;
+  for (int i = 0; i < kNumFramesToAdapt; ++i) {
+    VectorFloatFrame fake_audio(kMono, kFrameLen10ms8kHz, 1.0f);
+    helper.gain_applier->Process(info, fake_audio.float_frame_view());
+    applied_gain = fake_audio.float_frame_view().channel(0)[0];
+  }
+  const float applied_gain_db = 20.0f * std::log10f(applied_gain);
   EXPECT_NEAR(applied_gain_db, kMaxGainDb, 0.1f);
 }
 
-TEST(AutomaticGainController2AdaptiveGainApplier, GainDoesNotChangeFast) {
+TEST(GainController2AdaptiveGainApplier, GainDoesNotChangeFast) {
   GainApplierHelper helper;
 
-  constexpr float initial_level_dbfs = -25.f;
+  constexpr float initial_level_dbfs = -25.0f;
   // A few extra frames for safety.
   constexpr int kNumFramesToAdapt =
       static_cast<int>(initial_level_dbfs / kMaxGainChangePerFrameDb) + 10;
@@ -133,10 +105,10 @@
   float last_gain_linear = 1.f;
   for (int i = 0; i < kNumFramesToAdapt; ++i) {
     SCOPED_TRACE(i);
-    VectorFloatFrame fake_audio(kMono, kFrameLen10ms8kHz, 1.f);
+    VectorFloatFrame fake_audio(kMono, kFrameLen10ms8kHz, 1.0f);
     AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-    info.input_level_dbfs = initial_level_dbfs;
-    helper.gain_applier.Process(info, fake_audio.float_frame_view());
+    info.speech_level_dbfs = initial_level_dbfs;
+    helper.gain_applier->Process(info, fake_audio.float_frame_view());
     float current_gain_linear = fake_audio.float_frame_view().channel(0)[0];
     EXPECT_LE(std::abs(current_gain_linear - last_gain_linear),
               kMaxChangePerFrameLinear);
@@ -146,10 +118,10 @@
   // Check that the same is true when gain decreases as well.
   for (int i = 0; i < kNumFramesToAdapt; ++i) {
     SCOPED_TRACE(i);
-    VectorFloatFrame fake_audio(kMono, kFrameLen10ms8kHz, 1.f);
+    VectorFloatFrame fake_audio(kMono, kFrameLen10ms8kHz, 1.0f);
     AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-    info.input_level_dbfs = 0.f;
-    helper.gain_applier.Process(info, fake_audio.float_frame_view());
+    info.speech_level_dbfs = 0.f;
+    helper.gain_applier->Process(info, fake_audio.float_frame_view());
     float current_gain_linear = fake_audio.float_frame_view().channel(0)[0];
     EXPECT_LE(std::abs(current_gain_linear - last_gain_linear),
               kMaxChangePerFrameLinear);
@@ -157,17 +129,17 @@
   }
 }
 
-TEST(AutomaticGainController2AdaptiveGainApplier, GainIsRampedInAFrame) {
+TEST(GainController2AdaptiveGainApplier, GainIsRampedInAFrame) {
   GainApplierHelper helper;
 
-  constexpr float initial_level_dbfs = -25.f;
+  constexpr float initial_level_dbfs = -25.0f;
 
-  VectorFloatFrame fake_audio(kMono, kFrameLen10ms48kHz, 1.f);
+  VectorFloatFrame fake_audio(kMono, kFrameLen10ms48kHz, 1.0f);
   AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-  info.input_level_dbfs = initial_level_dbfs;
-  helper.gain_applier.Process(info, fake_audio.float_frame_view());
-  float maximal_difference = 0.f;
-  float current_value = 1.f * DbToRatio(kInitialAdaptiveDigitalGainDb);
+  info.speech_level_dbfs = initial_level_dbfs;
+  helper.gain_applier->Process(info, fake_audio.float_frame_view());
+  float maximal_difference = 0.0f;
+  float current_value = 1.0f * DbToRatio(kInitialAdaptiveDigitalGainDb);
   for (const auto& x : fake_audio.float_frame_view().channel(0)) {
     const float difference = std::abs(x - current_value);
     maximal_difference = std::max(maximal_difference, difference);
@@ -181,10 +153,10 @@
   EXPECT_LE(maximal_difference, kMaxChangePerSample);
 }
 
-TEST(AutomaticGainController2AdaptiveGainApplier, NoiseLimitsGain) {
+TEST(GainController2AdaptiveGainApplier, NoiseLimitsGain) {
   GainApplierHelper helper;
 
-  constexpr float initial_level_dbfs = -25.f;
+  constexpr float initial_level_dbfs = -25.0f;
   constexpr int num_initial_frames =
       kInitialAdaptiveDigitalGainDb / kMaxGainChangePerFrameDb;
   constexpr int num_frames = 50;
@@ -193,11 +165,11 @@
       << "kWithNoiseDbfs is too low";
 
   for (int i = 0; i < num_initial_frames + num_frames; ++i) {
-    VectorFloatFrame fake_audio(kMono, kFrameLen10ms48kHz, 1.f);
+    VectorFloatFrame fake_audio(kMono, kFrameLen10ms48kHz, 1.0f);
     AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-    info.input_level_dbfs = initial_level_dbfs;
-    info.input_noise_level_dbfs = kWithNoiseDbfs;
-    helper.gain_applier.Process(info, fake_audio.float_frame_view());
+    info.speech_level_dbfs = initial_level_dbfs;
+    info.noise_rms_dbfs = kWithNoiseDbfs;
+    helper.gain_applier->Process(info, fake_audio.float_frame_view());
 
     // Wait so that the adaptive gain applier has time to lower the gain.
     if (i > num_initial_frames) {
@@ -205,25 +177,25 @@
           *std::max_element(fake_audio.float_frame_view().channel(0).begin(),
                             fake_audio.float_frame_view().channel(0).end());
 
-      EXPECT_NEAR(maximal_ratio, 1.f, 0.001f);
+      EXPECT_NEAR(maximal_ratio, 1.0f, 0.001f);
     }
   }
 }
 
-TEST(AutomaticGainController2GainApplier, CanHandlePositiveSpeechLevels) {
+TEST(GainController2GainApplier, CanHandlePositiveSpeechLevels) {
   GainApplierHelper helper;
 
   // Make one call with positive audio level values and settings.
-  VectorFloatFrame fake_audio(kStereo, kFrameLen10ms48kHz, 10000.f);
+  VectorFloatFrame fake_audio(kStereo, kFrameLen10ms48kHz, 10000.0f);
   AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-  info.input_level_dbfs = 5.f;
-  helper.gain_applier.Process(info, fake_audio.float_frame_view());
+  info.speech_level_dbfs = 5.0f;
+  helper.gain_applier->Process(info, fake_audio.float_frame_view());
 }
 
-TEST(AutomaticGainController2GainApplier, AudioLevelLimitsGain) {
+TEST(GainController2GainApplier, AudioLevelLimitsGain) {
   GainApplierHelper helper;
 
-  constexpr float initial_level_dbfs = -25.f;
+  constexpr float initial_level_dbfs = -25.0f;
   constexpr int num_initial_frames =
       kInitialAdaptiveDigitalGainDb / kMaxGainChangePerFrameDb;
   constexpr int num_frames = 50;
@@ -232,12 +204,12 @@
       << "kWithNoiseDbfs is too low";
 
   for (int i = 0; i < num_initial_frames + num_frames; ++i) {
-    VectorFloatFrame fake_audio(kMono, kFrameLen10ms48kHz, 1.f);
+    VectorFloatFrame fake_audio(kMono, kFrameLen10ms48kHz, 1.0f);
     AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-    info.input_level_dbfs = initial_level_dbfs;
-    info.limiter_envelope_dbfs = 1.f;
-    info.estimate_is_confident = false;
-    helper.gain_applier.Process(info, fake_audio.float_frame_view());
+    info.speech_level_dbfs = initial_level_dbfs;
+    info.limiter_envelope_dbfs = 1.0f;
+    info.speech_level_reliable = false;
+    helper.gain_applier->Process(info, fake_audio.float_frame_view());
 
     // Wait so that the adaptive gain applier has time to lower the gain.
     if (i > num_initial_frames) {
@@ -245,7 +217,7 @@
           *std::max_element(fake_audio.float_frame_view().channel(0).begin(),
                             fake_audio.float_frame_view().channel(0).end());
 
-      EXPECT_NEAR(maximal_ratio, 1.f, 0.001f);
+      EXPECT_NEAR(maximal_ratio, 1.0f, 0.001f);
     }
   }
 }
@@ -260,14 +232,11 @@
   const int adjacent_speech_frames_threshold = AdjacentSpeechFramesThreshold();
   GainApplierHelper helper(adjacent_speech_frames_threshold);
 
-  AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-  info.input_level_dbfs = -25.0;
-
-  float prev_gain = 0.f;
+  float prev_gain = 0.0f;
   for (int i = 0; i < adjacent_speech_frames_threshold; ++i) {
     SCOPED_TRACE(i);
-    VectorFloatFrame audio(kMono, kFrameLen10ms48kHz, 1.f);
-    helper.gain_applier.Process(info, audio.float_frame_view());
+    VectorFloatFrame audio(kMono, kFrameLen10ms48kHz, 1.0f);
+    helper.gain_applier->Process(kFrameInfo, audio.float_frame_view());
     const float gain = audio.float_frame_view().channel(0)[0];
     if (i > 0) {
       EXPECT_EQ(prev_gain, gain);  // No gain increase.
@@ -280,25 +249,23 @@
   const int adjacent_speech_frames_threshold = AdjacentSpeechFramesThreshold();
   GainApplierHelper helper(adjacent_speech_frames_threshold);
 
-  AdaptiveDigitalGainApplier::FrameInfo info = kFrameInfo;
-  info.input_level_dbfs = -25.0;
-
-  float prev_gain = 0.f;
+  float prev_gain = 0.0f;
   for (int i = 0; i < adjacent_speech_frames_threshold; ++i) {
-    VectorFloatFrame audio(kMono, kFrameLen10ms48kHz, 1.f);
-    helper.gain_applier.Process(info, audio.float_frame_view());
+    SCOPED_TRACE(i);
+    VectorFloatFrame audio(kMono, kFrameLen10ms48kHz, 1.0f);
+    helper.gain_applier->Process(kFrameInfo, audio.float_frame_view());
     prev_gain = audio.float_frame_view().channel(0)[0];
   }
 
   // Process one more speech frame.
-  VectorFloatFrame audio(kMono, kFrameLen10ms48kHz, 1.f);
-  helper.gain_applier.Process(info, audio.float_frame_view());
+  VectorFloatFrame audio(kMono, kFrameLen10ms48kHz, 1.0f);
+  helper.gain_applier->Process(kFrameInfo, audio.float_frame_view());
 
   // The gain has increased.
   EXPECT_GT(audio.float_frame_view().channel(0)[0], prev_gain);
 }
 
-INSTANTIATE_TEST_SUITE_P(AutomaticGainController2,
+INSTANTIATE_TEST_SUITE_P(GainController2,
                          AdaptiveDigitalGainApplierTest,
                          ::testing::Values(1, 7, 31));
 
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc b/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc
index 9857471..507aa12 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc
@@ -22,37 +22,17 @@
 using LevelEstimatorType =
     AudioProcessing::Config::GainController2::LevelEstimator;
 
-// Combines a level estimation with the saturation protector margins.
-float ComputeLevelEstimateDbfs(float level_estimate_dbfs,
-                               float saturation_margin_db,
-                               float extra_saturation_margin_db) {
-  return rtc::SafeClamp<float>(
-      level_estimate_dbfs + saturation_margin_db + extra_saturation_margin_db,
-      -90.f, 30.f);
-}
-
-// Returns the level of given type from `vad_level`.
-float GetLevel(const VadLevelAnalyzer::Result& vad_level,
-               LevelEstimatorType type) {
-  switch (type) {
-    case LevelEstimatorType::kRms:
-      return vad_level.rms_dbfs;
-      break;
-    case LevelEstimatorType::kPeak:
-      return vad_level.peak_dbfs;
-      break;
-  }
-  RTC_CHECK_NOTREACHED();
+float ClampLevelEstimateDbfs(float level_estimate_dbfs) {
+  return rtc::SafeClamp<float>(level_estimate_dbfs, -90.f, 30.f);
 }
 
 }  // namespace
 
 bool AdaptiveModeLevelEstimator::LevelEstimatorState::operator==(
     const AdaptiveModeLevelEstimator::LevelEstimatorState& b) const {
-  return time_to_full_buffer_ms == b.time_to_full_buffer_ms &&
+  return time_to_confidence_ms == b.time_to_confidence_ms &&
          level_dbfs.numerator == b.level_dbfs.numerator &&
-         level_dbfs.denominator == b.level_dbfs.denominator &&
-         saturation_protector == b.saturation_protector;
+         level_dbfs.denominator == b.level_dbfs.denominator;
 }
 
 float AdaptiveModeLevelEstimator::LevelEstimatorState::Ratio::GetRatio() const {
@@ -64,25 +44,14 @@
     ApmDataDumper* apm_data_dumper)
     : AdaptiveModeLevelEstimator(
           apm_data_dumper,
-          AudioProcessing::Config::GainController2::LevelEstimator::kRms,
-          kDefaultLevelEstimatorAdjacentSpeechFramesThreshold,
-          kDefaultInitialSaturationMarginDb,
-          kDefaultExtraSaturationMarginDb) {}
+          kDefaultLevelEstimatorAdjacentSpeechFramesThreshold) {}
 
 AdaptiveModeLevelEstimator::AdaptiveModeLevelEstimator(
     ApmDataDumper* apm_data_dumper,
-    AudioProcessing::Config::GainController2::LevelEstimator level_estimator,
-    int adjacent_speech_frames_threshold,
-    float initial_saturation_margin_db,
-    float extra_saturation_margin_db)
+    int adjacent_speech_frames_threshold)
     : apm_data_dumper_(apm_data_dumper),
-      level_estimator_type_(level_estimator),
       adjacent_speech_frames_threshold_(adjacent_speech_frames_threshold),
-      initial_saturation_margin_db_(initial_saturation_margin_db),
-      extra_saturation_margin_db_(extra_saturation_margin_db),
-      level_dbfs_(ComputeLevelEstimateDbfs(kInitialSpeechLevelEstimateDbfs,
-                                           initial_saturation_margin_db_,
-                                           extra_saturation_margin_db_)) {
+      level_dbfs_(ClampLevelEstimateDbfs(kInitialSpeechLevelEstimateDbfs)) {
   RTC_DCHECK(apm_data_dumper_);
   RTC_DCHECK_GE(adjacent_speech_frames_threshold_, 1);
   Reset();
@@ -96,8 +65,6 @@
   RTC_DCHECK_LT(vad_level.peak_dbfs, 50.f);
   RTC_DCHECK_GE(vad_level.speech_probability, 0.f);
   RTC_DCHECK_LE(vad_level.speech_probability, 1.f);
-  DumpDebugData();
-
   if (vad_level.speech_probability < kVadConfidenceThreshold) {
     // Not a speech frame.
     if (adjacent_speech_frames_threshold_ > 1) {
@@ -115,89 +82,82 @@
       }
     }
     num_adjacent_speech_frames_ = 0;
-    return;
+  } else {
+    // Speech frame observed.
+    num_adjacent_speech_frames_++;
+
+    // Update preliminary level estimate.
+    RTC_DCHECK_GE(preliminary_state_.time_to_confidence_ms, 0);
+    const bool buffer_is_full = preliminary_state_.time_to_confidence_ms == 0;
+    if (!buffer_is_full) {
+      preliminary_state_.time_to_confidence_ms -= kFrameDurationMs;
+    }
+    // Weighted average of levels with speech probability as weight.
+    RTC_DCHECK_GT(vad_level.speech_probability, 0.f);
+    const float leak_factor = buffer_is_full ? kLevelEstimatorLeakFactor : 1.f;
+    preliminary_state_.level_dbfs.numerator =
+        preliminary_state_.level_dbfs.numerator * leak_factor +
+        vad_level.rms_dbfs * vad_level.speech_probability;
+    preliminary_state_.level_dbfs.denominator =
+        preliminary_state_.level_dbfs.denominator * leak_factor +
+        vad_level.speech_probability;
+
+    const float level_dbfs = preliminary_state_.level_dbfs.GetRatio();
+
+    if (num_adjacent_speech_frames_ >= adjacent_speech_frames_threshold_) {
+      // `preliminary_state_` is now reliable. Update the last level estimation.
+      level_dbfs_ = ClampLevelEstimateDbfs(level_dbfs);
+    }
   }
-
-  // Speech frame observed.
-  num_adjacent_speech_frames_++;
-
-  // Update preliminary level estimate.
-  RTC_DCHECK_GE(preliminary_state_.time_to_full_buffer_ms, 0);
-  const bool buffer_is_full = preliminary_state_.time_to_full_buffer_ms == 0;
-  if (!buffer_is_full) {
-    preliminary_state_.time_to_full_buffer_ms -= kFrameDurationMs;
-  }
-  // Weighted average of levels with speech probability as weight.
-  RTC_DCHECK_GT(vad_level.speech_probability, 0.f);
-  const float leak_factor = buffer_is_full ? kFullBufferLeakFactor : 1.f;
-  preliminary_state_.level_dbfs.numerator =
-      preliminary_state_.level_dbfs.numerator * leak_factor +
-      GetLevel(vad_level, level_estimator_type_) * vad_level.speech_probability;
-  preliminary_state_.level_dbfs.denominator =
-      preliminary_state_.level_dbfs.denominator * leak_factor +
-      vad_level.speech_probability;
-
-  const float level_dbfs = preliminary_state_.level_dbfs.GetRatio();
-
-  UpdateSaturationProtectorState(vad_level.peak_dbfs, level_dbfs,
-                                 preliminary_state_.saturation_protector);
-
-  if (num_adjacent_speech_frames_ >= adjacent_speech_frames_threshold_) {
-    // `preliminary_state_` is now reliable. Update the last level estimation.
-    level_dbfs_ = ComputeLevelEstimateDbfs(
-        level_dbfs, preliminary_state_.saturation_protector.margin_db,
-        extra_saturation_margin_db_);
-  }
+  DumpDebugData();
 }
 
 bool AdaptiveModeLevelEstimator::IsConfident() const {
   if (adjacent_speech_frames_threshold_ == 1) {
     // Ignore `reliable_state_` when a single frame is enough to update the
     // level estimate (because it is not used).
-    return preliminary_state_.time_to_full_buffer_ms == 0;
+    return preliminary_state_.time_to_confidence_ms == 0;
   }
   // Once confident, it remains confident.
-  RTC_DCHECK(reliable_state_.time_to_full_buffer_ms != 0 ||
-             preliminary_state_.time_to_full_buffer_ms == 0);
+  RTC_DCHECK(reliable_state_.time_to_confidence_ms != 0 ||
+             preliminary_state_.time_to_confidence_ms == 0);
   // During the first long enough speech sequence, `reliable_state_` must be
   // ignored since `preliminary_state_` is used.
-  return reliable_state_.time_to_full_buffer_ms == 0 ||
+  return reliable_state_.time_to_confidence_ms == 0 ||
          (num_adjacent_speech_frames_ >= adjacent_speech_frames_threshold_ &&
-          preliminary_state_.time_to_full_buffer_ms == 0);
+          preliminary_state_.time_to_confidence_ms == 0);
 }
 
 void AdaptiveModeLevelEstimator::Reset() {
   ResetLevelEstimatorState(preliminary_state_);
   ResetLevelEstimatorState(reliable_state_);
-  level_dbfs_ = ComputeLevelEstimateDbfs(kInitialSpeechLevelEstimateDbfs,
-                                         initial_saturation_margin_db_,
-                                         extra_saturation_margin_db_);
+  level_dbfs_ = ClampLevelEstimateDbfs(kInitialSpeechLevelEstimateDbfs);
   num_adjacent_speech_frames_ = 0;
 }
 
 void AdaptiveModeLevelEstimator::ResetLevelEstimatorState(
     LevelEstimatorState& state) const {
-  state.time_to_full_buffer_ms = kFullBufferSizeMs;
-  state.level_dbfs.numerator = 0.f;
-  state.level_dbfs.denominator = 0.f;
-  ResetSaturationProtectorState(initial_saturation_margin_db_,
-                                state.saturation_protector);
+  state.time_to_confidence_ms = kLevelEstimatorTimeToConfidenceMs;
+  state.level_dbfs.numerator = kInitialSpeechLevelEstimateDbfs;
+  state.level_dbfs.denominator = 1.0f;
 }
 
 void AdaptiveModeLevelEstimator::DumpDebugData() const {
-  apm_data_dumper_->DumpRaw("agc2_adaptive_level_estimate_dbfs", level_dbfs_);
-  apm_data_dumper_->DumpRaw("agc2_adaptive_num_adjacent_speech_frames",
-                            num_adjacent_speech_frames_);
-  apm_data_dumper_->DumpRaw("agc2_adaptive_preliminary_level_estimate_num",
-                            preliminary_state_.level_dbfs.numerator);
-  apm_data_dumper_->DumpRaw("agc2_adaptive_preliminary_level_estimate_den",
-                            preliminary_state_.level_dbfs.denominator);
-  apm_data_dumper_->DumpRaw("agc2_adaptive_preliminary_saturation_margin_db",
-                            preliminary_state_.saturation_protector.margin_db);
-  apm_data_dumper_->DumpRaw("agc2_adaptive_preliminary_time_to_full_buffer_ms",
-                            preliminary_state_.time_to_full_buffer_ms);
-  apm_data_dumper_->DumpRaw("agc2_adaptive_reliable_time_to_full_buffer_ms",
-                            reliable_state_.time_to_full_buffer_ms);
+  apm_data_dumper_->DumpRaw(
+      "agc2_adaptive_level_estimator_num_adjacent_speech_frames",
+      num_adjacent_speech_frames_);
+  apm_data_dumper_->DumpRaw(
+      "agc2_adaptive_level_estimator_preliminary_level_estimate_num",
+      preliminary_state_.level_dbfs.numerator);
+  apm_data_dumper_->DumpRaw(
+      "agc2_adaptive_level_estimator_preliminary_level_estimate_den",
+      preliminary_state_.level_dbfs.denominator);
+  apm_data_dumper_->DumpRaw(
+      "agc2_adaptive_level_estimator_preliminary_time_to_confidence_ms",
+      preliminary_state_.time_to_confidence_ms);
+  apm_data_dumper_->DumpRaw(
+      "agc2_adaptive_level_estimator_reliable_time_to_confidence_ms",
+      reliable_state_.time_to_confidence_ms);
 }
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator.h b/modules/audio_processing/agc2/adaptive_mode_level_estimator.h
index 213fc0f..6d44938 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator.h
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator.h
@@ -15,7 +15,6 @@
 #include <type_traits>
 
 #include "modules/audio_processing/agc2/agc2_common.h"
-#include "modules/audio_processing/agc2/saturation_protector.h"
 #include "modules/audio_processing/agc2/vad_with_level.h"
 #include "modules/audio_processing/include/audio_processing.h"
 
@@ -29,12 +28,8 @@
   AdaptiveModeLevelEstimator(const AdaptiveModeLevelEstimator&) = delete;
   AdaptiveModeLevelEstimator& operator=(const AdaptiveModeLevelEstimator&) =
       delete;
-  AdaptiveModeLevelEstimator(
-      ApmDataDumper* apm_data_dumper,
-      AudioProcessing::Config::GainController2::LevelEstimator level_estimator,
-      int adjacent_speech_frames_threshold,
-      float initial_saturation_margin_db,
-      float extra_saturation_margin_db);
+  AdaptiveModeLevelEstimator(ApmDataDumper* apm_data_dumper,
+                             int adjacent_speech_frames_threshold);
 
   // Updates the level estimation.
   void Update(const VadLevelAnalyzer::Result& vad_data);
@@ -57,10 +52,9 @@
       float denominator;
       float GetRatio() const;
     };
-    // TODO(crbug.com/webrtc/7494): Remove time_to_full_buffer_ms if redundant.
-    int time_to_full_buffer_ms;
+    // TODO(crbug.com/webrtc/7494): Remove time_to_confidence_ms if redundant.
+    int time_to_confidence_ms;
     Ratio level_dbfs;
-    SaturationProtectorState saturation_protector;
   };
   static_assert(std::is_trivially_copyable<LevelEstimatorState>::value, "");
 
@@ -70,11 +64,7 @@
 
   ApmDataDumper* const apm_data_dumper_;
 
-  const AudioProcessing::Config::GainController2::LevelEstimator
-      level_estimator_type_;
   const int adjacent_speech_frames_threshold_;
-  const float initial_saturation_margin_db_;
-  const float extra_saturation_margin_db_;
   LevelEstimatorState preliminary_state_;
   LevelEstimatorState reliable_state_;
   float level_dbfs_;
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator_unittest.cc b/modules/audio_processing/agc2/adaptive_mode_level_estimator_unittest.cc
index ea35797..c55950a 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator_unittest.cc
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator_unittest.cc
@@ -19,22 +19,34 @@
 namespace webrtc {
 namespace {
 
-constexpr float kInitialSaturationMarginDb = 20.f;
-constexpr float kExtraSaturationMarginDb = 2.f;
+// Number of speech frames that the level estimator must observe in order to
+// become confident about the estimated level.
+constexpr int kNumFramesToConfidence =
+    kLevelEstimatorTimeToConfidenceMs / kFrameDurationMs;
+static_assert(kNumFramesToConfidence > 0, "");
 
-static_assert(kInitialSpeechLevelEstimateDbfs < 0.f, "");
-constexpr float kVadLevelRms = kInitialSpeechLevelEstimateDbfs / 2.f;
-constexpr float kVadLevelPeak = kInitialSpeechLevelEstimateDbfs / 3.f;
+// Fake levels and speech probabilities used in the tests.
+static_assert(kInitialSpeechLevelEstimateDbfs < 0.0f, "");
+constexpr float kVadLevelRms = kInitialSpeechLevelEstimateDbfs / 2.0f;
+constexpr float kVadLevelPeak = kInitialSpeechLevelEstimateDbfs / 3.0f;
+static_assert(kVadLevelRms < kVadLevelPeak, "");
+static_assert(kVadLevelRms > kInitialSpeechLevelEstimateDbfs, "");
+static_assert(kVadLevelRms - kInitialSpeechLevelEstimateDbfs > 5.0f,
+              "Adjust `kVadLevelRms` so that the difference from the initial "
+              "level is wide enough for the tests.");
 
-constexpr VadLevelAnalyzer::Result kVadDataSpeech{/*speech_probability=*/1.f,
+constexpr VadLevelAnalyzer::Result kVadDataSpeech{/*speech_probability=*/1.0f,
                                                   kVadLevelRms, kVadLevelPeak};
 constexpr VadLevelAnalyzer::Result kVadDataNonSpeech{
-    /*speech_probability=*/kVadConfidenceThreshold / 2.f, kVadLevelRms,
+    /*speech_probability=*/kVadConfidenceThreshold / 2.0f, kVadLevelRms,
     kVadLevelPeak};
 
-constexpr float kMinSpeechProbability = 0.f;
-constexpr float kMaxSpeechProbability = 1.f;
+constexpr float kMinSpeechProbability = 0.0f;
+constexpr float kMaxSpeechProbability = 1.0f;
 
+constexpr float kConvergenceSpeedTestsLevelTolerance = 0.5f;
+
+// Provides the `vad_level` value `num_iterations` times to `level_estimator`.
 void RunOnConstantLevel(int num_iterations,
                         const VadLevelAnalyzer::Result& vad_level,
                         AdaptiveModeLevelEstimator& level_estimator) {
@@ -43,172 +55,125 @@
   }
 }
 
+// Level estimator with data dumper.
 struct TestLevelEstimator {
   TestLevelEstimator()
       : data_dumper(0),
         estimator(std::make_unique<AdaptiveModeLevelEstimator>(
             &data_dumper,
-            AudioProcessing::Config::GainController2::LevelEstimator::kRms,
-            /*adjacent_speech_frames_threshold=*/1,
-            kInitialSaturationMarginDb,
-            kExtraSaturationMarginDb)) {}
+            /*adjacent_speech_frames_threshold=*/1)) {}
   ApmDataDumper data_dumper;
   std::unique_ptr<AdaptiveModeLevelEstimator> estimator;
 };
 
-TEST(AutomaticGainController2AdaptiveModeLevelEstimator,
-     EstimatorShouldNotCrash) {
+// Checks the initially estimated level.
+TEST(GainController2AdaptiveModeLevelEstimator, CheckInitialEstimate) {
   TestLevelEstimator level_estimator;
-
-  VadLevelAnalyzer::Result vad_level{kMaxSpeechProbability, /*rms_dbfs=*/-20.f,
-                                     /*peak_dbfs=*/-10.f};
-  level_estimator.estimator->Update(vad_level);
-  static_cast<void>(level_estimator.estimator->level_dbfs());
+  EXPECT_FLOAT_EQ(level_estimator.estimator->level_dbfs(),
+                  kInitialSpeechLevelEstimateDbfs);
 }
 
-TEST(AutomaticGainController2AdaptiveModeLevelEstimator, LevelShouldStabilize) {
+// Checks that the level estimator converges to a constant input speech level.
+TEST(GainController2AdaptiveModeLevelEstimator, LevelStabilizes) {
   TestLevelEstimator level_estimator;
-
-  constexpr float kSpeechPeakDbfs = -15.f;
-  RunOnConstantLevel(100,
-                     VadLevelAnalyzer::Result{kMaxSpeechProbability,
-                                              /*rms_dbfs=*/kSpeechPeakDbfs -
-                                                  kInitialSaturationMarginDb,
-                                              kSpeechPeakDbfs},
+  RunOnConstantLevel(/*num_iterations=*/kNumFramesToConfidence, kVadDataSpeech,
                      *level_estimator.estimator);
-
-  EXPECT_NEAR(
-      level_estimator.estimator->level_dbfs() - kExtraSaturationMarginDb,
-      kSpeechPeakDbfs, 0.1f);
+  const float estimated_level_dbfs = level_estimator.estimator->level_dbfs();
+  RunOnConstantLevel(/*num_iterations=*/1, kVadDataSpeech,
+                     *level_estimator.estimator);
+  EXPECT_NEAR(level_estimator.estimator->level_dbfs(), estimated_level_dbfs,
+              0.1f);
 }
 
-TEST(AutomaticGainController2AdaptiveModeLevelEstimator,
-     EstimatorIgnoresZeroProbabilityFrames) {
+// Checks that the level controller does not become confident when too few
+// speech frames are observed.
+TEST(GainController2AdaptiveModeLevelEstimator, IsNotConfident) {
   TestLevelEstimator level_estimator;
+  RunOnConstantLevel(/*num_iterations=*/kNumFramesToConfidence / 2,
+                     kVadDataSpeech, *level_estimator.estimator);
+  EXPECT_FALSE(level_estimator.estimator->IsConfident());
+}
 
-  // Run for one second of fake audio.
-  constexpr float kSpeechRmsDbfs = -25.f;
-  RunOnConstantLevel(100,
-                     VadLevelAnalyzer::Result{kMaxSpeechProbability,
-                                              /*rms_dbfs=*/kSpeechRmsDbfs -
-                                                  kInitialSaturationMarginDb,
-                                              /*peak_dbfs=*/kSpeechRmsDbfs},
+// Checks that the level controller becomes confident when enough speech frames
+// are observed.
+TEST(GainController2AdaptiveModeLevelEstimator, IsConfident) {
+  TestLevelEstimator level_estimator;
+  RunOnConstantLevel(/*num_iterations=*/kNumFramesToConfidence, kVadDataSpeech,
                      *level_estimator.estimator);
+  EXPECT_TRUE(level_estimator.estimator->IsConfident());
+}
 
-  // Run for one more second, but mark as not speech.
-  constexpr float kNoiseRmsDbfs = 0.f;
-  RunOnConstantLevel(100,
+// Checks that the estimated level is not affected by the level of non-speech
+// frames.
+TEST(GainController2AdaptiveModeLevelEstimator,
+     EstimatorIgnoresNonSpeechFrames) {
+  TestLevelEstimator level_estimator;
+  // Simulate speech.
+  RunOnConstantLevel(/*num_iterations=*/kNumFramesToConfidence, kVadDataSpeech,
+                     *level_estimator.estimator);
+  const float estimated_level_dbfs = level_estimator.estimator->level_dbfs();
+  // Simulate full-scale non-speech.
+  RunOnConstantLevel(/*num_iterations=*/kNumFramesToConfidence,
                      VadLevelAnalyzer::Result{kMinSpeechProbability,
-                                              /*rms_dbfs=*/kNoiseRmsDbfs,
-                                              /*peak_dbfs=*/kNoiseRmsDbfs},
+                                              /*rms_dbfs=*/0.0f,
+                                              /*peak_dbfs=*/0.0f},
                      *level_estimator.estimator);
-
-  // Level should not have changed.
-  EXPECT_NEAR(
-      level_estimator.estimator->level_dbfs() - kExtraSaturationMarginDb,
-      kSpeechRmsDbfs, 0.1f);
+  // No estimated level change is expected.
+  EXPECT_FLOAT_EQ(level_estimator.estimator->level_dbfs(),
+                  estimated_level_dbfs);
 }
 
-TEST(AutomaticGainController2AdaptiveModeLevelEstimator, TimeToAdapt) {
+// Checks the convergence speed of the estimator before it becomes confident.
+TEST(GainController2AdaptiveModeLevelEstimator,
+     ConvergenceSpeedBeforeConfidence) {
   TestLevelEstimator level_estimator;
-
-  // Run for one 'window size' interval.
-  constexpr float kInitialSpeechRmsDbfs = -30.f;
-  RunOnConstantLevel(
-      kFullBufferSizeMs / kFrameDurationMs,
-      VadLevelAnalyzer::Result{
-          kMaxSpeechProbability,
-          /*rms_dbfs=*/kInitialSpeechRmsDbfs - kInitialSaturationMarginDb,
-          /*peak_dbfs=*/kInitialSpeechRmsDbfs},
-      *level_estimator.estimator);
-
-  // Run for one half 'window size' interval. This should not be enough to
-  // adapt.
-  constexpr float kDifferentSpeechRmsDbfs = -10.f;
-  // It should at most differ by 25% after one half 'window size' interval.
-  // TODO(crbug.com/webrtc/7494): Add constexpr for repeated expressions.
-  const float kMaxDifferenceDb =
-      0.25f * std::abs(kDifferentSpeechRmsDbfs - kInitialSpeechRmsDbfs);
-  RunOnConstantLevel(
-      static_cast<int>(kFullBufferSizeMs / kFrameDurationMs / 2),
-      VadLevelAnalyzer::Result{
-          kMaxSpeechProbability,
-          /*rms_dbfs=*/kDifferentSpeechRmsDbfs - kInitialSaturationMarginDb,
-          /*peak_dbfs=*/kDifferentSpeechRmsDbfs},
-      *level_estimator.estimator);
-  EXPECT_GT(std::abs(kDifferentSpeechRmsDbfs -
-                     level_estimator.estimator->level_dbfs()),
-            kMaxDifferenceDb);
-
-  // Run for some more time. Afterwards, we should have adapted.
-  RunOnConstantLevel(
-      static_cast<int>(3 * kFullBufferSizeMs / kFrameDurationMs),
-      VadLevelAnalyzer::Result{
-          kMaxSpeechProbability,
-          /*rms_dbfs=*/kDifferentSpeechRmsDbfs - kInitialSaturationMarginDb,
-          /*peak_dbfs=*/kDifferentSpeechRmsDbfs},
-      *level_estimator.estimator);
-  EXPECT_NEAR(
-      level_estimator.estimator->level_dbfs() - kExtraSaturationMarginDb,
-      kDifferentSpeechRmsDbfs, kMaxDifferenceDb * 0.5f);
+  RunOnConstantLevel(/*num_iterations=*/kNumFramesToConfidence, kVadDataSpeech,
+                     *level_estimator.estimator);
+  EXPECT_NEAR(level_estimator.estimator->level_dbfs(), kVadDataSpeech.rms_dbfs,
+              kConvergenceSpeedTestsLevelTolerance);
 }
 
-TEST(AutomaticGainController2AdaptiveModeLevelEstimator,
-     ResetGivesFastAdaptation) {
+// Checks the convergence speed of the estimator after it becomes confident.
+TEST(GainController2AdaptiveModeLevelEstimator,
+     ConvergenceSpeedAfterConfidence) {
   TestLevelEstimator level_estimator;
-
-  // Run the level estimator for one window size interval. This gives time to
-  // adapt.
-  constexpr float kInitialSpeechRmsDbfs = -30.f;
+  // Reach confidence using the initial level estimate.
   RunOnConstantLevel(
-      kFullBufferSizeMs / kFrameDurationMs,
+      /*num_iterations=*/kNumFramesToConfidence,
       VadLevelAnalyzer::Result{
           kMaxSpeechProbability,
-          /*rms_dbfs=*/kInitialSpeechRmsDbfs - kInitialSaturationMarginDb,
-          /*peak_dbfs=*/kInitialSpeechRmsDbfs},
+          /*rms_dbfs=*/kInitialSpeechLevelEstimateDbfs,
+          /*peak_dbfs=*/kInitialSpeechLevelEstimateDbfs + 6.0f},
       *level_estimator.estimator);
-
-  constexpr float kDifferentSpeechRmsDbfs = -10.f;
-  // Reset and run one half window size interval.
-  level_estimator.estimator->Reset();
-
+  // No estimate change should occur, but confidence is achieved.
+  ASSERT_FLOAT_EQ(level_estimator.estimator->level_dbfs(),
+                  kInitialSpeechLevelEstimateDbfs);
+  ASSERT_TRUE(level_estimator.estimator->IsConfident());
+  // After confidence.
+  constexpr float kConvergenceTimeAfterConfidenceNumFrames = 600;  // 6 seconds.
+  static_assert(
+      kConvergenceTimeAfterConfidenceNumFrames > kNumFramesToConfidence, "");
   RunOnConstantLevel(
-      kFullBufferSizeMs / kFrameDurationMs / 2,
-      VadLevelAnalyzer::Result{
-          kMaxSpeechProbability,
-          /*rms_dbfs=*/kDifferentSpeechRmsDbfs - kInitialSaturationMarginDb,
-          /*peak_dbfs=*/kDifferentSpeechRmsDbfs},
-      *level_estimator.estimator);
-
-  // The level should be close to 'kDifferentSpeechRmsDbfs'.
-  const float kMaxDifferenceDb =
-      0.1f * std::abs(kDifferentSpeechRmsDbfs - kInitialSpeechRmsDbfs);
-  EXPECT_LT(std::abs(kDifferentSpeechRmsDbfs -
-                     (level_estimator.estimator->level_dbfs() -
-                      kExtraSaturationMarginDb)),
-            kMaxDifferenceDb);
+      /*num_iterations=*/kConvergenceTimeAfterConfidenceNumFrames,
+      kVadDataSpeech, *level_estimator.estimator);
+  EXPECT_NEAR(level_estimator.estimator->level_dbfs(), kVadDataSpeech.rms_dbfs,
+              kConvergenceSpeedTestsLevelTolerance);
 }
 
-struct TestConfig {
-  int min_consecutive_speech_frames;
-  float initial_saturation_margin_db;
-  float extra_saturation_margin_db;
+class AdaptiveModeLevelEstimatorParametrization
+    : public ::testing::TestWithParam<int> {
+ protected:
+  int adjacent_speech_frames_threshold() const { return GetParam(); }
 };
 
-class AdaptiveModeLevelEstimatorTest
-    : public ::testing::TestWithParam<TestConfig> {};
-
-TEST_P(AdaptiveModeLevelEstimatorTest, DoNotAdaptToShortSpeechSegments) {
-  const auto params = GetParam();
+TEST_P(AdaptiveModeLevelEstimatorParametrization,
+       DoNotAdaptToShortSpeechSegments) {
   ApmDataDumper apm_data_dumper(0);
   AdaptiveModeLevelEstimator level_estimator(
-      &apm_data_dumper,
-      AudioProcessing::Config::GainController2::LevelEstimator::kRms,
-      params.min_consecutive_speech_frames, params.initial_saturation_margin_db,
-      params.extra_saturation_margin_db);
+      &apm_data_dumper, adjacent_speech_frames_threshold());
   const float initial_level = level_estimator.level_dbfs();
-  ASSERT_LT(initial_level, kVadDataSpeech.rms_dbfs);
-  for (int i = 0; i < params.min_consecutive_speech_frames - 1; ++i) {
+  ASSERT_LT(initial_level, kVadDataSpeech.peak_dbfs);
+  for (int i = 0; i < adjacent_speech_frames_threshold() - 1; ++i) {
     SCOPED_TRACE(i);
     level_estimator.Update(kVadDataSpeech);
     EXPECT_EQ(initial_level, level_estimator.level_dbfs());
@@ -217,26 +182,21 @@
   EXPECT_EQ(initial_level, level_estimator.level_dbfs());
 }
 
-TEST_P(AdaptiveModeLevelEstimatorTest, AdaptToEnoughSpeechSegments) {
-  const auto params = GetParam();
+TEST_P(AdaptiveModeLevelEstimatorParametrization, AdaptToEnoughSpeechSegments) {
   ApmDataDumper apm_data_dumper(0);
   AdaptiveModeLevelEstimator level_estimator(
-      &apm_data_dumper,
-      AudioProcessing::Config::GainController2::LevelEstimator::kRms,
-      params.min_consecutive_speech_frames, params.initial_saturation_margin_db,
-      params.extra_saturation_margin_db);
+      &apm_data_dumper, adjacent_speech_frames_threshold());
   const float initial_level = level_estimator.level_dbfs();
-  ASSERT_LT(initial_level, kVadDataSpeech.rms_dbfs);
-  for (int i = 0; i < params.min_consecutive_speech_frames; ++i) {
+  ASSERT_LT(initial_level, kVadDataSpeech.peak_dbfs);
+  for (int i = 0; i < adjacent_speech_frames_threshold(); ++i) {
     level_estimator.Update(kVadDataSpeech);
   }
   EXPECT_LT(initial_level, level_estimator.level_dbfs());
 }
 
-INSTANTIATE_TEST_SUITE_P(AutomaticGainController2,
-                         AdaptiveModeLevelEstimatorTest,
-                         ::testing::Values(TestConfig{1, 0.f, 0.f},
-                                           TestConfig{9, 0.f, 0.f}));
+INSTANTIATE_TEST_SUITE_P(GainController2,
+                         AdaptiveModeLevelEstimatorParametrization,
+                         ::testing::Values(1, 9, 17));
 
 }  // namespace
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/agc2_common.h b/modules/audio_processing/agc2/agc2_common.h
index ccd04bc..0f806d3 100644
--- a/modules/audio_processing/agc2/agc2_common.h
+++ b/modules/audio_processing/agc2/agc2_common.h
@@ -11,20 +11,19 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_AGC2_COMMON_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_AGC2_COMMON_H_
 
-#include <stddef.h>
-
 namespace webrtc {
 
 constexpr float kMinFloatS16Value = -32768.0f;
 constexpr float kMaxFloatS16Value = 32767.0f;
 constexpr float kMaxAbsFloatS16Value = 32768.0f;
 
+// Minimum audio level in dBFS scale for S16 samples.
+constexpr float kMinLevelDbfs = -90.31f;
+
 constexpr int kFrameDurationMs = 10;
 constexpr int kSubFramesInFrame = 20;
 constexpr int kMaximalNumberOfSamplesPerChannel = 480;
 
-constexpr float kAttackFilterConstant = 0.0f;
-
 // Adaptive digital gain applier settings below.
 constexpr float kHeadroomDbfs = 1.0f;
 constexpr float kMaxGainDb = 30.0f;
@@ -37,43 +36,29 @@
 // gain reduction.
 constexpr float kVadConfidenceThreshold = 0.95f;
 
-// The amount of 'memory' of the Level Estimator. Decides leak factors.
-constexpr int kFullBufferSizeMs = 1200;
-constexpr float kFullBufferLeakFactor = 1.0f - 1.0f / kFullBufferSizeMs;
-
-constexpr float kInitialSpeechLevelEstimateDbfs = -30.0f;
+// Adaptive digital level estimator parameters.
+// Number of milliseconds of speech frames to observe to make the estimator
+// confident.
+constexpr float kLevelEstimatorTimeToConfidenceMs = 400;
+constexpr float kLevelEstimatorLeakFactor =
+    1.0f - 1.0f / kLevelEstimatorTimeToConfidenceMs;
 
 // Robust VAD probability and speech decisions.
 constexpr int kDefaultVadRnnResetPeriodMs = 1500;
 static_assert(kDefaultVadRnnResetPeriodMs % kFrameDurationMs == 0, "");
-constexpr float kDefaultSmoothedVadProbabilityAttack = 1.0f;
-constexpr int kDefaultLevelEstimatorAdjacentSpeechFramesThreshold = 1;
+constexpr int kDefaultLevelEstimatorAdjacentSpeechFramesThreshold = 12;
 
 // Saturation Protector settings.
-constexpr float kDefaultInitialSaturationMarginDb = 20.0f;
-constexpr float kDefaultExtraSaturationMarginDb = 2.0f;
+constexpr float kSaturationProtectorInitialHeadroomDb = 20.0f;
+constexpr float kSaturationProtectorExtraHeadroomDb = 5.0f;
+constexpr int kSaturationProtectorBufferSize = 4;
 
-constexpr int kPeakEnveloperSuperFrameLengthMs = 400;
-static_assert(kFullBufferSizeMs % kPeakEnveloperSuperFrameLengthMs == 0,
-              "Full buffer size should be a multiple of super frame length for "
-              "optimal Saturation Protector performance.");
-
-constexpr int kPeakEnveloperBufferSize =
-    kFullBufferSizeMs / kPeakEnveloperSuperFrameLengthMs + 1;
-
-// This value is 10 ** (-1/20 * frame_size_ms / satproc_attack_ms),
-// where satproc_attack_ms is 5000.
-constexpr float kSaturationProtectorAttackConstant = 0.9988493699365052f;
-
-// This value is 10 ** (-1/20 * frame_size_ms / satproc_decay_ms),
-// where satproc_decay_ms is 1000.
-constexpr float kSaturationProtectorDecayConstant = 0.9997697679981565f;
-
-// This is computed from kDecayMs by
-// 10 ** (-1/20 * subframe_duration / kDecayMs).
-// |subframe_duration| is |kFrameDurationMs / kSubFramesInFrame|.
-// kDecayMs is defined in agc2_testing_common.h
-constexpr float kDecayFilterConstant = 0.9998848773724686f;
+// Set the initial speech level estimate so that `kInitialAdaptiveDigitalGainDb`
+// is applied at the beginning of the call.
+constexpr float kInitialSpeechLevelEstimateDbfs =
+    -kSaturationProtectorExtraHeadroomDb -
+    kSaturationProtectorInitialHeadroomDb - kInitialAdaptiveDigitalGainDb -
+    kHeadroomDbfs;
 
 // Number of interpolation points for each region of the limiter.
 // These values have been tuned to limit the interpolated gain curve error given
diff --git a/modules/audio_processing/agc2/agc2_testing_common_unittest.cc b/modules/audio_processing/agc2/agc2_testing_common_unittest.cc
index f52ea3c..79c3cc9 100644
--- a/modules/audio_processing/agc2/agc2_testing_common_unittest.cc
+++ b/modules/audio_processing/agc2/agc2_testing_common_unittest.cc
@@ -14,7 +14,7 @@
 
 namespace webrtc {
 
-TEST(AutomaticGainController2Common, TestLinSpace) {
+TEST(GainController2TestingCommon, LinSpace) {
   std::vector<double> points1 = test::LinSpace(-1.0, 2.0, 4);
   const std::vector<double> expected_points1{{-1.0, 0.0, 1.0, 2.0}};
   EXPECT_EQ(expected_points1, points1);
diff --git a/modules/audio_processing/agc2/fixed_digital_level_estimator.cc b/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
index 9636136..3e9bb2e 100644
--- a/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
+++ b/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
@@ -22,6 +22,14 @@
 
 constexpr float kInitialFilterStateLevel = 0.f;
 
+// Instant attack.
+constexpr float kAttackFilterConstant = 0.f;
+// This is computed from kDecayMs by
+// 10 ** (-1/20 * subframe_duration / kDecayMs).
+// |subframe_duration| is |kFrameDurationMs / kSubFramesInFrame|.
+// kDecayMs is defined in agc2_testing_common.h
+constexpr float kDecayFilterConstant = 0.9998848773724686f;
+
 }  // namespace
 
 FixedDigitalLevelEstimator::FixedDigitalLevelEstimator(
diff --git a/modules/audio_processing/agc2/fixed_digital_level_estimator_unittest.cc b/modules/audio_processing/agc2/fixed_digital_level_estimator_unittest.cc
index 7547f8e..97b421d 100644
--- a/modules/audio_processing/agc2/fixed_digital_level_estimator_unittest.cc
+++ b/modules/audio_processing/agc2/fixed_digital_level_estimator_unittest.cc
@@ -101,25 +101,25 @@
 }
 }  // namespace
 
-TEST(AutomaticGainController2LevelEstimator, EstimatorShouldNotCrash) {
+TEST(GainController2FixedDigitalLevelEstimator, EstimatorShouldNotCrash) {
   TestLevelEstimator(8000, 1, 0, std::numeric_limits<float>::lowest(),
                      std::numeric_limits<float>::max());
 }
 
-TEST(AutomaticGainController2LevelEstimator,
+TEST(GainController2FixedDigitalLevelEstimator,
      EstimatorShouldEstimateConstantLevel) {
   TestLevelEstimator(10000, 1, kInputLevel, kInputLevel * 0.99,
                      kInputLevel * 1.01);
 }
 
-TEST(AutomaticGainController2LevelEstimator,
+TEST(GainController2FixedDigitalLevelEstimator,
      EstimatorShouldEstimateConstantLevelForManyChannels) {
   constexpr size_t num_channels = 10;
   TestLevelEstimator(20000, num_channels, kInputLevel, kInputLevel * 0.99,
                      kInputLevel * 1.01);
 }
 
-TEST(AutomaticGainController2LevelEstimator, TimeToDecreaseForLowLevel) {
+TEST(GainController2FixedDigitalLevelEstimator, TimeToDecreaseForLowLevel) {
   constexpr float kLevelReductionDb = 25;
   constexpr float kInitialLowLevel = -40;
   constexpr float kExpectedTime = kLevelReductionDb * test::kDecayMs;
@@ -131,7 +131,8 @@
   EXPECT_LE(time_to_decrease, kExpectedTime * 1.1);
 }
 
-TEST(AutomaticGainController2LevelEstimator, TimeToDecreaseForFullScaleLevel) {
+TEST(GainController2FixedDigitalLevelEstimator,
+     TimeToDecreaseForFullScaleLevel) {
   constexpr float kLevelReductionDb = 25;
   constexpr float kExpectedTime = kLevelReductionDb * test::kDecayMs;
 
@@ -142,7 +143,7 @@
   EXPECT_LE(time_to_decrease, kExpectedTime * 1.1);
 }
 
-TEST(AutomaticGainController2LevelEstimator,
+TEST(GainController2FixedDigitalLevelEstimator,
      TimeToDecreaseForMultipleChannels) {
   constexpr float kLevelReductionDb = 25;
   constexpr float kExpectedTime = kLevelReductionDb * test::kDecayMs;
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve.h b/modules/audio_processing/agc2/interpolated_gain_curve.h
index 69652c5..af99320 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve.h
+++ b/modules/audio_processing/agc2/interpolated_gain_curve.h
@@ -75,7 +75,7 @@
  private:
   // For comparing 'approximation_params_*_' with ones computed by
   // ComputeInterpolatedGainCurve.
-  FRIEND_TEST_ALL_PREFIXES(AutomaticGainController2InterpolatedGainCurve,
+  FRIEND_TEST_ALL_PREFIXES(GainController2InterpolatedGainCurve,
                            CheckApproximationParams);
 
   struct RegionLogger {
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc b/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
index 67d34e5..7861ae9 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
+++ b/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
@@ -34,7 +34,7 @@
 
 }  // namespace
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CreateUse) {
+TEST(GainController2InterpolatedGainCurve, CreateUse) {
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
@@ -44,7 +44,7 @@
   }
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CheckValidOutput) {
+TEST(GainController2InterpolatedGainCurve, CheckValidOutput) {
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
@@ -57,7 +57,7 @@
   }
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CheckMonotonicity) {
+TEST(GainController2InterpolatedGainCurve, CheckMonotonicity) {
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
@@ -71,7 +71,7 @@
   }
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CheckApproximation) {
+TEST(GainController2InterpolatedGainCurve, CheckApproximation) {
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
@@ -84,7 +84,7 @@
   }
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CheckRegionBoundaries) {
+TEST(GainController2InterpolatedGainCurve, CheckRegionBoundaries) {
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const std::vector<double> levels{
@@ -102,7 +102,7 @@
   EXPECT_EQ(1ul, stats.look_ups_saturation_region);
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CheckIdentityRegion) {
+TEST(GainController2InterpolatedGainCurve, CheckIdentityRegion) {
   constexpr size_t kNumSteps = 10;
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
@@ -120,8 +120,7 @@
   EXPECT_EQ(0ul, stats.look_ups_saturation_region);
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve,
-     CheckNoOverApproximationKnee) {
+TEST(GainController2InterpolatedGainCurve, CheckNoOverApproximationKnee) {
   constexpr size_t kNumSteps = 10;
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
@@ -142,8 +141,7 @@
   EXPECT_EQ(0ul, stats.look_ups_saturation_region);
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve,
-     CheckNoOverApproximationBeyondKnee) {
+TEST(GainController2InterpolatedGainCurve, CheckNoOverApproximationBeyondKnee) {
   constexpr size_t kNumSteps = 10;
   InterpolatedGainCurve igc(&apm_data_dumper, "");
 
@@ -164,7 +162,7 @@
   EXPECT_EQ(0ul, stats.look_ups_saturation_region);
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve,
+TEST(GainController2InterpolatedGainCurve,
      CheckNoOverApproximationWithSaturation) {
   constexpr size_t kNumSteps = 3;
   InterpolatedGainCurve igc(&apm_data_dumper, "");
@@ -184,7 +182,7 @@
   EXPECT_EQ(kNumSteps, stats.look_ups_saturation_region);
 }
 
-TEST(AutomaticGainController2InterpolatedGainCurve, CheckApproximationParams) {
+TEST(GainController2InterpolatedGainCurve, CheckApproximationParams) {
   test::InterpolatedParameters parameters =
       test::ComputeInterpolatedGainCurveApproximationParams();
 
diff --git a/modules/audio_processing/agc2/noise_level_estimator.cc b/modules/audio_processing/agc2/noise_level_estimator.cc
index ae8a501..10e8437 100644
--- a/modules/audio_processing/agc2/noise_level_estimator.cc
+++ b/modules/audio_processing/agc2/noise_level_estimator.cc
@@ -184,7 +184,7 @@
     const float frame_energy = FrameEnergy(frame);
     if (frame_energy <= min_noise_energy_) {
       // Ignore frames when muted or below the minimum measurable energy.
-      data_dumper_->DumpRaw("agc2_noise_floor_preliminary_level",
+      data_dumper_->DumpRaw("agc2_noise_floor_estimator_preliminary_level",
                             noise_energy_);
       return EnergyToDbfs(noise_energy_, frame.samples_per_channel());
     }
@@ -196,7 +196,7 @@
       preliminary_noise_energy_ = frame_energy;
       preliminary_noise_energy_set_ = true;
     }
-    data_dumper_->DumpRaw("agc2_noise_floor_preliminary_level",
+    data_dumper_->DumpRaw("agc2_noise_floor_estimator_preliminary_level",
                           preliminary_noise_energy_);
 
     if (counter_ == 0) {
diff --git a/modules/audio_processing/agc2/saturation_protector.cc b/modules/audio_processing/agc2/saturation_protector.cc
index b64fcdb..d6f21ef 100644
--- a/modules/audio_processing/agc2/saturation_protector.cc
+++ b/modules/audio_processing/agc2/saturation_protector.cc
@@ -10,84 +10,59 @@
 
 #include "modules/audio_processing/agc2/saturation_protector.h"
 
+#include <memory>
+
+#include "modules/audio_processing/agc2/agc2_common.h"
+#include "modules/audio_processing/agc2/saturation_protector_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
 namespace webrtc {
 namespace {
 
-constexpr float kMinLevelDbfs = -90.f;
+constexpr int kPeakEnveloperSuperFrameLengthMs = 400;
+constexpr float kMinMarginDb = 12.0f;
+constexpr float kMaxMarginDb = 25.0f;
+constexpr float kAttack = 0.9988493699365052f;
+constexpr float kDecay = 0.9997697679981565f;
 
-// Min/max margins are based on speech crest-factor.
-constexpr float kMinMarginDb = 12.f;
-constexpr float kMaxMarginDb = 25.f;
-
-using saturation_protector_impl::RingBuffer;
-
-}  // namespace
-
-bool RingBuffer::operator==(const RingBuffer& b) const {
-  RTC_DCHECK_LE(size_, buffer_.size());
-  RTC_DCHECK_LE(b.size_, b.buffer_.size());
-  if (size_ != b.size_) {
-    return false;
+// Saturation protector state. Defined outside of `SaturationProtectorImpl` to
+// implement check-point and restore ops.
+struct SaturationProtectorState {
+  bool operator==(const SaturationProtectorState& s) const {
+    return headroom_db == s.headroom_db &&
+           peak_delay_buffer == s.peak_delay_buffer &&
+           max_peaks_dbfs == s.max_peaks_dbfs &&
+           time_since_push_ms == s.time_since_push_ms;
   }
-  for (int i = 0, i0 = FrontIndex(), i1 = b.FrontIndex(); i < size_;
-       ++i, ++i0, ++i1) {
-    if (buffer_[i0 % buffer_.size()] != b.buffer_[i1 % b.buffer_.size()]) {
-      return false;
-    }
+  inline bool operator!=(const SaturationProtectorState& s) const {
+    return !(*this == s);
   }
-  return true;
-}
 
-void RingBuffer::Reset() {
-  next_ = 0;
-  size_ = 0;
-}
+  float headroom_db;
+  SaturationProtectorBuffer peak_delay_buffer;
+  float max_peaks_dbfs;
+  int time_since_push_ms;  // Time since the last ring buffer push operation.
+};
 
-void RingBuffer::PushBack(float v) {
-  RTC_DCHECK_GE(next_, 0);
-  RTC_DCHECK_GE(size_, 0);
-  RTC_DCHECK_LT(next_, buffer_.size());
-  RTC_DCHECK_LE(size_, buffer_.size());
-  buffer_[next_++] = v;
-  if (rtc::SafeEq(next_, buffer_.size())) {
-    next_ = 0;
-  }
-  if (rtc::SafeLt(size_, buffer_.size())) {
-    size_++;
-  }
-}
-
-absl::optional<float> RingBuffer::Front() const {
-  if (size_ == 0) {
-    return absl::nullopt;
-  }
-  RTC_DCHECK_LT(FrontIndex(), buffer_.size());
-  return buffer_[FrontIndex()];
-}
-
-bool SaturationProtectorState::operator==(
-    const SaturationProtectorState& b) const {
-  return margin_db == b.margin_db && peak_delay_buffer == b.peak_delay_buffer &&
-         max_peaks_dbfs == b.max_peaks_dbfs &&
-         time_since_push_ms == b.time_since_push_ms;
-}
-
-void ResetSaturationProtectorState(float initial_margin_db,
+// Resets the saturation protector state.
+void ResetSaturationProtectorState(float initial_headroom_db,
                                    SaturationProtectorState& state) {
-  state.margin_db = initial_margin_db;
+  state.headroom_db = initial_headroom_db;
   state.peak_delay_buffer.Reset();
   state.max_peaks_dbfs = kMinLevelDbfs;
   state.time_since_push_ms = 0;
 }
 
-void UpdateSaturationProtectorState(float speech_peak_dbfs,
+// Updates `state` by analyzing the estimated speech level `speech_level_dbfs`
+// and the peak level `peak_dbfs` for an observed frame. `state` must not be
+// modified without calling this function.
+void UpdateSaturationProtectorState(float peak_dbfs,
                                     float speech_level_dbfs,
                                     SaturationProtectorState& state) {
   // Get the max peak over `kPeakEnveloperSuperFrameLengthMs` ms.
-  state.max_peaks_dbfs = std::max(state.max_peaks_dbfs, speech_peak_dbfs);
+  state.max_peaks_dbfs = std::max(state.max_peaks_dbfs, peak_dbfs);
   state.time_since_push_ms += kFrameDurationMs;
   if (rtc::SafeGt(state.time_since_push_ms, kPeakEnveloperSuperFrameLengthMs)) {
     // Push `max_peaks_dbfs` back into the ring buffer.
@@ -97,25 +72,117 @@
     state.time_since_push_ms = 0;
   }
 
-  // Update margin by comparing the estimated speech level and the delayed max
-  // speech peak power.
-  // TODO(alessiob): Check with aleloi@ why we use a delay and how to tune it.
+  // Update the headroom by comparing the estimated speech level and the delayed
+  // max speech peak.
   const float delayed_peak_dbfs =
       state.peak_delay_buffer.Front().value_or(state.max_peaks_dbfs);
   const float difference_db = delayed_peak_dbfs - speech_level_dbfs;
-  if (difference_db > state.margin_db) {
+  if (difference_db > state.headroom_db) {
     // Attack.
-    state.margin_db =
-        state.margin_db * kSaturationProtectorAttackConstant +
-        difference_db * (1.f - kSaturationProtectorAttackConstant);
+    state.headroom_db =
+        state.headroom_db * kAttack + difference_db * (1.0f - kAttack);
   } else {
     // Decay.
-    state.margin_db = state.margin_db * kSaturationProtectorDecayConstant +
-                      difference_db * (1.f - kSaturationProtectorDecayConstant);
+    state.headroom_db =
+        state.headroom_db * kDecay + difference_db * (1.0f - kDecay);
   }
 
-  state.margin_db =
-      rtc::SafeClamp<float>(state.margin_db, kMinMarginDb, kMaxMarginDb);
+  state.headroom_db =
+      rtc::SafeClamp<float>(state.headroom_db, kMinMarginDb, kMaxMarginDb);
+}
+
+// Saturation protector which recommends a headroom based on the recent peaks.
+class SaturationProtectorImpl : public SaturationProtector {
+ public:
+  explicit SaturationProtectorImpl(float initial_headroom_db,
+                                   float extra_headroom_db,
+                                   int adjacent_speech_frames_threshold,
+                                   ApmDataDumper* apm_data_dumper)
+      : apm_data_dumper_(apm_data_dumper),
+        initial_headroom_db_(initial_headroom_db),
+        extra_headroom_db_(extra_headroom_db),
+        adjacent_speech_frames_threshold_(adjacent_speech_frames_threshold) {
+    Reset();
+  }
+  SaturationProtectorImpl(const SaturationProtectorImpl&) = delete;
+  SaturationProtectorImpl& operator=(const SaturationProtectorImpl&) = delete;
+  ~SaturationProtectorImpl() = default;
+
+  float HeadroomDb() override { return headroom_db_; }
+
+  void Analyze(float speech_probability,
+               float peak_dbfs,
+               float speech_level_dbfs) override {
+    if (speech_probability < kVadConfidenceThreshold) {
+      // Not a speech frame.
+      if (adjacent_speech_frames_threshold_ > 1) {
+        // When two or more adjacent speech frames are required in order to
+        // update the state, we need to decide whether to discard or confirm the
+        // updates based on the speech sequence length.
+        if (num_adjacent_speech_frames_ >= adjacent_speech_frames_threshold_) {
+          // First non-speech frame after a long enough sequence of speech
+          // frames. Update the reliable state.
+          reliable_state_ = preliminary_state_;
+        } else if (num_adjacent_speech_frames_ > 0) {
+          // First non-speech frame after a too short sequence of speech frames.
+          // Reset to the last reliable state.
+          preliminary_state_ = reliable_state_;
+        }
+      }
+      num_adjacent_speech_frames_ = 0;
+    } else {
+      // Speech frame observed.
+      num_adjacent_speech_frames_++;
+
+      // Update preliminary level estimate.
+      UpdateSaturationProtectorState(peak_dbfs, speech_level_dbfs,
+                                     preliminary_state_);
+
+      if (num_adjacent_speech_frames_ >= adjacent_speech_frames_threshold_) {
+        // `preliminary_state_` is now reliable. Update the headroom.
+        headroom_db_ = preliminary_state_.headroom_db + extra_headroom_db_;
+      }
+    }
+    DumpDebugData();
+  }
+
+  void Reset() override {
+    num_adjacent_speech_frames_ = 0;
+    headroom_db_ = initial_headroom_db_ + extra_headroom_db_;
+    ResetSaturationProtectorState(initial_headroom_db_, preliminary_state_);
+    ResetSaturationProtectorState(initial_headroom_db_, reliable_state_);
+  }
+
+ private:
+  void DumpDebugData() {
+    apm_data_dumper_->DumpRaw(
+        "agc2_saturation_protector_preliminary_max_peak_dbfs",
+        preliminary_state_.max_peaks_dbfs);
+    apm_data_dumper_->DumpRaw(
+        "agc2_saturation_protector_reliable_max_peak_dbfs",
+        reliable_state_.max_peaks_dbfs);
+  }
+
+  ApmDataDumper* const apm_data_dumper_;
+  const float initial_headroom_db_;
+  const float extra_headroom_db_;
+  const int adjacent_speech_frames_threshold_;
+  int num_adjacent_speech_frames_;
+  float headroom_db_;
+  SaturationProtectorState preliminary_state_;
+  SaturationProtectorState reliable_state_;
+};
+
+}  // namespace
+
+std::unique_ptr<SaturationProtector> CreateSaturationProtector(
+    float initial_headroom_db,
+    float extra_headroom_db,
+    int adjacent_speech_frames_threshold,
+    ApmDataDumper* apm_data_dumper) {
+  return std::make_unique<SaturationProtectorImpl>(
+      initial_headroom_db, extra_headroom_db, adjacent_speech_frames_threshold,
+      apm_data_dumper);
 }
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/saturation_protector.h b/modules/audio_processing/agc2/saturation_protector.h
index 88be91a..0c384f1 100644
--- a/modules/audio_processing/agc2/saturation_protector.h
+++ b/modules/audio_processing/agc2/saturation_protector.h
@@ -11,71 +11,36 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_SATURATION_PROTECTOR_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_SATURATION_PROTECTOR_H_
 
-#include <array>
-
-#include "absl/types/optional.h"
-#include "modules/audio_processing/agc2/agc2_common.h"
-#include "rtc_base/numerics/safe_compare.h"
+#include <memory>
 
 namespace webrtc {
-namespace saturation_protector_impl {
+class ApmDataDumper;
 
-// Ring buffer which only supports (i) push back and (ii) read oldest item.
-class RingBuffer {
+// Saturation protector. Analyzes peak levels and recommends a headroom to
+// reduce the chances of clipping.
+class SaturationProtector {
  public:
-  bool operator==(const RingBuffer& b) const;
-  inline bool operator!=(const RingBuffer& b) const { return !(*this == b); }
+  virtual ~SaturationProtector() = default;
 
-  // Maximum number of values that the buffer can contain.
-  int Capacity() const { return buffer_.size(); }
-  // Number of values in the buffer.
-  int Size() const { return size_; }
+  // Returns the recommended headroom in dB.
+  virtual float HeadroomDb() = 0;
 
-  void Reset();
-  // Pushes back `v`. If the buffer is full, the oldest value is replaced.
-  void PushBack(float v);
-  // Returns the oldest item in the buffer. Returns an empty value if the
-  // buffer is empty.
-  absl::optional<float> Front() const;
+  // Analyzes the peak level of a 10 ms frame along with its speech probability
+  // and the current speech level estimate to update the recommended headroom.
+  virtual void Analyze(float speech_probability,
+                       float peak_dbfs,
+                       float speech_level_dbfs) = 0;
 
- private:
-  inline int FrontIndex() const {
-    return rtc::SafeEq(size_, buffer_.size()) ? next_ : 0;
-  }
-  // `buffer_` has `size_` elements (up to the size of `buffer_`) and `next_` is
-  // the position where the next new value is written in `buffer_`.
-  std::array<float, kPeakEnveloperBufferSize> buffer_;
-  int next_ = 0;
-  int size_ = 0;
+  // Resets the internal state.
+  virtual void Reset() = 0;
 };
 
-}  // namespace saturation_protector_impl
-
-// Saturation protector state. Exposed publicly for check-pointing and restore
-// ops.
-struct SaturationProtectorState {
-  bool operator==(const SaturationProtectorState& s) const;
-  inline bool operator!=(const SaturationProtectorState& s) const {
-    return !(*this == s);
-  }
-
-  float margin_db;  // Recommended margin.
-  saturation_protector_impl::RingBuffer peak_delay_buffer;
-  float max_peaks_dbfs;
-  int time_since_push_ms;  // Time since the last ring buffer push operation.
-};
-
-// Resets the saturation protector state.
-void ResetSaturationProtectorState(float initial_margin_db,
-                                   SaturationProtectorState& state);
-
-// Updates `state` by analyzing the estimated speech level `speech_level_dbfs`
-// and the peak power `speech_peak_dbfs` for an observed frame which is
-// reliably classified as "speech". `state` must not be modified without calling
-// this function.
-void UpdateSaturationProtectorState(float speech_peak_dbfs,
-                                    float speech_level_dbfs,
-                                    SaturationProtectorState& state);
+// Creates a saturation protector that starts at `initial_headroom_db`.
+std::unique_ptr<SaturationProtector> CreateSaturationProtector(
+    float initial_headroom_db,
+    float extra_headroom_db,
+    int adjacent_speech_frames_threshold,
+    ApmDataDumper* apm_data_dumper);
 
 }  // namespace webrtc
 
diff --git a/modules/audio_processing/agc2/saturation_protector_buffer.cc b/modules/audio_processing/agc2/saturation_protector_buffer.cc
new file mode 100644
index 0000000..41efdad
--- /dev/null
+++ b/modules/audio_processing/agc2/saturation_protector_buffer.cc
@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2021 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/saturation_protector_buffer.h"
+
+#include "rtc_base/checks.h"
+#include "rtc_base/numerics/safe_compare.h"
+
+namespace webrtc {
+
+SaturationProtectorBuffer::SaturationProtectorBuffer() = default;
+
+SaturationProtectorBuffer::~SaturationProtectorBuffer() = default;
+
+bool SaturationProtectorBuffer::operator==(
+    const SaturationProtectorBuffer& b) const {
+  RTC_DCHECK_LE(size_, buffer_.size());
+  RTC_DCHECK_LE(b.size_, b.buffer_.size());
+  if (size_ != b.size_) {
+    return false;
+  }
+  for (int i = 0, i0 = FrontIndex(), i1 = b.FrontIndex(); i < size_;
+       ++i, ++i0, ++i1) {
+    if (buffer_[i0 % buffer_.size()] != b.buffer_[i1 % b.buffer_.size()]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+int SaturationProtectorBuffer::Capacity() const {
+  return buffer_.size();
+}
+
+int SaturationProtectorBuffer::Size() const {
+  return size_;
+}
+
+void SaturationProtectorBuffer::Reset() {
+  next_ = 0;
+  size_ = 0;
+}
+
+void SaturationProtectorBuffer::PushBack(float v) {
+  RTC_DCHECK_GE(next_, 0);
+  RTC_DCHECK_GE(size_, 0);
+  RTC_DCHECK_LT(next_, buffer_.size());
+  RTC_DCHECK_LE(size_, buffer_.size());
+  buffer_[next_++] = v;
+  if (rtc::SafeEq(next_, buffer_.size())) {
+    next_ = 0;
+  }
+  if (rtc::SafeLt(size_, buffer_.size())) {
+    size_++;
+  }
+}
+
+absl::optional<float> SaturationProtectorBuffer::Front() const {
+  if (size_ == 0) {
+    return absl::nullopt;
+  }
+  RTC_DCHECK_LT(FrontIndex(), buffer_.size());
+  return buffer_[FrontIndex()];
+}
+
+int SaturationProtectorBuffer::FrontIndex() const {
+  return rtc::SafeEq(size_, buffer_.size()) ? next_ : 0;
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/saturation_protector_buffer.h b/modules/audio_processing/agc2/saturation_protector_buffer.h
new file mode 100644
index 0000000..e17d099
--- /dev/null
+++ b/modules/audio_processing/agc2/saturation_protector_buffer.h
@@ -0,0 +1,59 @@
+/*
+ *  Copyright (c) 2021 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_SATURATION_PROTECTOR_BUFFER_H_
+#define MODULES_AUDIO_PROCESSING_AGC2_SATURATION_PROTECTOR_BUFFER_H_
+
+#include <array>
+
+#include "absl/types/optional.h"
+#include "modules/audio_processing/agc2/agc2_common.h"
+
+namespace webrtc {
+
+// Ring buffer for the saturation protector which only supports (i) push back
+// and (ii) read oldest item.
+class SaturationProtectorBuffer {
+ public:
+  SaturationProtectorBuffer();
+  ~SaturationProtectorBuffer();
+
+  bool operator==(const SaturationProtectorBuffer& b) const;
+  inline bool operator!=(const SaturationProtectorBuffer& b) const {
+    return !(*this == b);
+  }
+
+  // Maximum number of values that the buffer can contain.
+  int Capacity() const;
+
+  // Number of values in the buffer.
+  int Size() const;
+
+  void Reset();
+
+  // Pushes back `v`. If the buffer is full, the oldest value is replaced.
+  void PushBack(float v);
+
+  // Returns the oldest item in the buffer. Returns an empty value if the
+  // buffer is empty.
+  absl::optional<float> Front() const;
+
+ private:
+  int FrontIndex() const;
+  // `buffer_` has `size_` elements (up to the size of `buffer_`) and `next_` is
+  // the position where the next new value is written in `buffer_`.
+  std::array<float, kSaturationProtectorBufferSize> buffer_;
+  int next_ = 0;
+  int size_ = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_AGC2_SATURATION_PROTECTOR_BUFFER_H_
diff --git a/modules/audio_processing/agc2/saturation_protector_buffer_unittest.cc b/modules/audio_processing/agc2/saturation_protector_buffer_unittest.cc
new file mode 100644
index 0000000..22187bf
--- /dev/null
+++ b/modules/audio_processing/agc2/saturation_protector_buffer_unittest.cc
@@ -0,0 +1,73 @@
+/*
+ *  Copyright (c) 2021 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/saturation_protector_buffer.h"
+
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+namespace {
+
+using ::testing::Eq;
+using ::testing::Optional;
+
+TEST(GainController2SaturationProtectorBuffer, Init) {
+  SaturationProtectorBuffer b;
+  EXPECT_EQ(b.Size(), 0);
+  EXPECT_FALSE(b.Front().has_value());
+}
+
+TEST(GainController2SaturationProtectorBuffer, PushBack) {
+  SaturationProtectorBuffer b;
+  constexpr float kValue = 123.0f;
+  b.PushBack(kValue);
+  EXPECT_EQ(b.Size(), 1);
+  EXPECT_THAT(b.Front(), Optional(Eq(kValue)));
+}
+
+TEST(GainController2SaturationProtectorBuffer, Reset) {
+  SaturationProtectorBuffer b;
+  b.PushBack(123.0f);
+  b.Reset();
+  EXPECT_EQ(b.Size(), 0);
+  EXPECT_FALSE(b.Front().has_value());
+}
+
+// Checks that the front value does not change until the ring buffer gets full.
+TEST(GainController2SaturationProtectorBuffer, FrontUntilBufferIsFull) {
+  SaturationProtectorBuffer b;
+  constexpr float kValue = 123.0f;
+  b.PushBack(kValue);
+  for (int i = 1; i < b.Capacity(); ++i) {
+    SCOPED_TRACE(i);
+    EXPECT_THAT(b.Front(), Optional(Eq(kValue)));
+    b.PushBack(kValue + i);
+  }
+}
+
+// Checks that when the buffer is full it behaves as a shift register.
+TEST(GainController2SaturationProtectorBuffer, FrontIsDelayed) {
+  SaturationProtectorBuffer b;
+  // Fill the buffer.
+  for (int i = 0; i < b.Capacity(); ++i) {
+    b.PushBack(i);
+  }
+  // The ring buffer should now behave as a shift register with a delay equal to
+  // its capacity.
+  for (int i = b.Capacity(); i < 2 * b.Capacity() + 1; ++i) {
+    SCOPED_TRACE(i);
+    EXPECT_THAT(b.Front(), Optional(Eq(i - b.Capacity())));
+    b.PushBack(i);
+  }
+}
+
+}  // namespace
+}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/saturation_protector_unittest.cc b/modules/audio_processing/agc2/saturation_protector_unittest.cc
index 2c5ee5b..dc16dc2 100644
--- a/modules/audio_processing/agc2/saturation_protector_unittest.cc
+++ b/modules/audio_processing/agc2/saturation_protector_unittest.cc
@@ -10,181 +10,166 @@
 
 #include "modules/audio_processing/agc2/saturation_protector.h"
 
-#include <algorithm>
-
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/gunit.h"
-#include "test/gmock.h"
 
 namespace webrtc {
 namespace {
 
-constexpr float kInitialMarginDb = 20.f;
+constexpr float kInitialHeadroomDb = 20.0f;
+constexpr float kNoExtraHeadroomDb = 0.0f;
+constexpr int kNoAdjacentSpeechFramesRequired = 1;
+constexpr float kMaxSpeechProbability = 1.0f;
 
-using saturation_protector_impl::RingBuffer;
-
-SaturationProtectorState CreateSaturationProtectorState() {
-  SaturationProtectorState state;
-  ResetSaturationProtectorState(kInitialMarginDb, state);
-  return state;
-}
-
-// Updates `state` for `num_iterations` times with constant speech level and
-// peak powers and returns the maximum margin.
+// Calls `Analyze(speech_probability, peak_dbfs, speech_level_dbfs)`
+// `num_iterations` times on `saturation_protector` and return the largest
+// headroom difference between two consecutive calls.
 float RunOnConstantLevel(int num_iterations,
-                         float speech_peak_dbfs,
+                         float speech_probability,
+                         float peak_dbfs,
                          float speech_level_dbfs,
-                         SaturationProtectorState& state) {
-  float last_margin = state.margin_db;
-  float max_difference = 0.f;
+                         SaturationProtector& saturation_protector) {
+  float last_headroom = saturation_protector.HeadroomDb();
+  float max_difference = 0.0f;
   for (int i = 0; i < num_iterations; ++i) {
-    UpdateSaturationProtectorState(speech_peak_dbfs, speech_level_dbfs, state);
-    const float new_margin = state.margin_db;
+    saturation_protector.Analyze(speech_probability, peak_dbfs,
+                                 speech_level_dbfs);
+    const float new_headroom = saturation_protector.HeadroomDb();
     max_difference =
-        std::max(max_difference, std::abs(new_margin - last_margin));
-    last_margin = new_margin;
+        std::max(max_difference, std::fabs(new_headroom - last_headroom));
+    last_headroom = new_headroom;
   }
   return max_difference;
 }
 
-}  // namespace
-
-TEST(AutomaticGainController2SaturationProtector, RingBufferInit) {
-  RingBuffer b;
-  EXPECT_EQ(b.Size(), 0);
-  EXPECT_FALSE(b.Front().has_value());
-}
-
-TEST(AutomaticGainController2SaturationProtector, RingBufferPushBack) {
-  RingBuffer b;
-  constexpr float kValue = 123.f;
-  b.PushBack(kValue);
-  EXPECT_EQ(b.Size(), 1);
-  ASSERT_TRUE(b.Front().has_value());
-  EXPECT_EQ(b.Front().value(), kValue);
-}
-
-TEST(AutomaticGainController2SaturationProtector, RingBufferReset) {
-  RingBuffer b;
-  b.PushBack(123.f);
-  b.Reset();
-  EXPECT_EQ(b.Size(), 0);
-  EXPECT_FALSE(b.Front().has_value());
-}
-
-// Checks that the front value does not change until the ring buffer gets full.
-TEST(AutomaticGainController2SaturationProtector,
-     RingBufferFrontUntilBufferIsFull) {
-  RingBuffer b;
-  constexpr float kValue = 123.f;
-  b.PushBack(kValue);
-  for (int i = 1; i < b.Capacity(); ++i) {
-    EXPECT_EQ(b.Front().value(), kValue);
-    b.PushBack(kValue + i);
-  }
-}
-
-// Checks that when the buffer is full it behaves as a shift register.
-TEST(AutomaticGainController2SaturationProtector,
-     FullRingBufferFrontIsDelayed) {
-  RingBuffer b;
-  // Fill the buffer.
-  for (int i = 0; i < b.Capacity(); ++i) {
-    b.PushBack(i);
-  }
-  // The ring buffer should now behave as a shift register with a delay equal to
-  // its capacity.
-  for (int i = b.Capacity(); i < 2 * b.Capacity() + 1; ++i) {
-    EXPECT_EQ(b.Front().value(), i - b.Capacity());
-    b.PushBack(i);
-  }
-}
-
-// Checks that a state after reset equals a state after construction.
-TEST(AutomaticGainController2SaturationProtector, ResetState) {
-  SaturationProtectorState init_state;
-  ResetSaturationProtectorState(kInitialMarginDb, init_state);
-
-  SaturationProtectorState state;
-  ResetSaturationProtectorState(kInitialMarginDb, state);
-  RunOnConstantLevel(/*num_iterations=*/10, /*speech_level_dbfs=*/-20.f,
-                     /*speech_peak_dbfs=*/-10.f, state);
-  ASSERT_NE(init_state, state);  // Make sure that there are side-effects.
-  ResetSaturationProtectorState(kInitialMarginDb, state);
-
-  EXPECT_EQ(init_state, state);
+// Checks that the returned headroom value is correctly reset.
+TEST(GainController2SaturationProtector, Reset) {
+  ApmDataDumper apm_data_dumper(0);
+  auto saturation_protector = CreateSaturationProtector(
+      kInitialHeadroomDb, kNoExtraHeadroomDb, kNoAdjacentSpeechFramesRequired,
+      &apm_data_dumper);
+  const float initial_headroom_db = saturation_protector->HeadroomDb();
+  RunOnConstantLevel(/*num_iterations=*/10, kMaxSpeechProbability,
+                     /*peak_dbfs=*/0.0f,
+                     /*speech_level_dbfs=*/-10.0f, *saturation_protector);
+  // Make sure that there are side-effects.
+  ASSERT_NE(initial_headroom_db, saturation_protector->HeadroomDb());
+  saturation_protector->Reset();
+  EXPECT_EQ(initial_headroom_db, saturation_protector->HeadroomDb());
 }
 
 // Checks that the estimate converges to the ratio between peaks and level
 // estimator values after a while.
-TEST(AutomaticGainController2SaturationProtector,
-     ProtectorEstimatesCrestRatio) {
+TEST(GainController2SaturationProtector, EstimatesCrestRatio) {
   constexpr int kNumIterations = 2000;
-  constexpr float kPeakLevel = -20.f;
-  constexpr float kCrestFactor = kInitialMarginDb + 1.f;
-  constexpr float kSpeechLevel = kPeakLevel - kCrestFactor;
-  const float kMaxDifference = 0.5f * std::abs(kInitialMarginDb - kCrestFactor);
+  constexpr float kPeakLevelDbfs = -20.0f;
+  constexpr float kCrestFactorDb = kInitialHeadroomDb + 1.0f;
+  constexpr float kSpeechLevelDbfs = kPeakLevelDbfs - kCrestFactorDb;
+  const float kMaxDifferenceDb =
+      0.5f * std::fabs(kInitialHeadroomDb - kCrestFactorDb);
 
-  auto state = CreateSaturationProtectorState();
-  RunOnConstantLevel(kNumIterations, kPeakLevel, kSpeechLevel, state);
-
-  EXPECT_NEAR(state.margin_db, kCrestFactor, kMaxDifference);
+  ApmDataDumper apm_data_dumper(0);
+  auto saturation_protector = CreateSaturationProtector(
+      kInitialHeadroomDb, kNoExtraHeadroomDb, kNoAdjacentSpeechFramesRequired,
+      &apm_data_dumper);
+  RunOnConstantLevel(kNumIterations, kMaxSpeechProbability, kPeakLevelDbfs,
+                     kSpeechLevelDbfs, *saturation_protector);
+  EXPECT_NEAR(saturation_protector->HeadroomDb(), kCrestFactorDb,
+              kMaxDifferenceDb);
 }
 
-// Checks that the margin does not change too quickly.
-TEST(AutomaticGainController2SaturationProtector, ChangeSlowly) {
+// Checks that the extra headroom is applied.
+TEST(GainController2SaturationProtector, ExtraHeadroomApplied) {
+  constexpr float kExtraHeadroomDb = 5.1234f;
+  constexpr int kNumIterations = 10;
+  constexpr float kPeakLevelDbfs = -20.0f;
+  constexpr float kSpeechLevelDbfs = kPeakLevelDbfs - 15.0f;
+
+  ApmDataDumper apm_data_dumper(0);
+
+  auto saturation_protector_no_extra = CreateSaturationProtector(
+      kInitialHeadroomDb, kNoExtraHeadroomDb, kNoAdjacentSpeechFramesRequired,
+      &apm_data_dumper);
+  for (int i = 0; i < kNumIterations; ++i) {
+    saturation_protector_no_extra->Analyze(kMaxSpeechProbability,
+                                           kPeakLevelDbfs, kSpeechLevelDbfs);
+  }
+
+  auto saturation_protector_extra = CreateSaturationProtector(
+      kInitialHeadroomDb, kExtraHeadroomDb, kNoAdjacentSpeechFramesRequired,
+      &apm_data_dumper);
+  for (int i = 0; i < kNumIterations; ++i) {
+    saturation_protector_extra->Analyze(kMaxSpeechProbability, kPeakLevelDbfs,
+                                        kSpeechLevelDbfs);
+  }
+
+  EXPECT_EQ(saturation_protector_no_extra->HeadroomDb() + kExtraHeadroomDb,
+            saturation_protector_extra->HeadroomDb());
+}
+
+// Checks that the headroom does not change too quickly.
+TEST(GainController2SaturationProtector, ChangeSlowly) {
   constexpr int kNumIterations = 1000;
-  constexpr float kPeakLevel = -20.f;
-  constexpr float kCrestFactor = kInitialMarginDb - 5.f;
-  constexpr float kOtherCrestFactor = kInitialMarginDb;
-  constexpr float kSpeechLevel = kPeakLevel - kCrestFactor;
-  constexpr float kOtherSpeechLevel = kPeakLevel - kOtherCrestFactor;
+  constexpr float kPeakLevelDbfs = -20.f;
+  constexpr float kCrestFactorDb = kInitialHeadroomDb - 5.f;
+  constexpr float kOtherCrestFactorDb = kInitialHeadroomDb;
+  constexpr float kSpeechLevelDbfs = kPeakLevelDbfs - kCrestFactorDb;
+  constexpr float kOtherSpeechLevelDbfs = kPeakLevelDbfs - kOtherCrestFactorDb;
 
-  auto state = CreateSaturationProtectorState();
-  float max_difference =
-      RunOnConstantLevel(kNumIterations, kPeakLevel, kSpeechLevel, state);
-  max_difference = std::max(
-      RunOnConstantLevel(kNumIterations, kPeakLevel, kOtherSpeechLevel, state),
-      max_difference);
-
+  ApmDataDumper apm_data_dumper(0);
+  auto saturation_protector = CreateSaturationProtector(
+      kInitialHeadroomDb, kNoExtraHeadroomDb, kNoAdjacentSpeechFramesRequired,
+      &apm_data_dumper);
+  float max_difference_db =
+      RunOnConstantLevel(kNumIterations, kMaxSpeechProbability, kPeakLevelDbfs,
+                         kSpeechLevelDbfs, *saturation_protector);
+  max_difference_db = std::max(
+      RunOnConstantLevel(kNumIterations, kMaxSpeechProbability, kPeakLevelDbfs,
+                         kOtherSpeechLevelDbfs, *saturation_protector),
+      max_difference_db);
   constexpr float kMaxChangeSpeedDbPerSecond = 0.5f;  // 1 db / 2 seconds.
-  EXPECT_LE(max_difference,
+  EXPECT_LE(max_difference_db,
             kMaxChangeSpeedDbPerSecond / 1000 * kFrameDurationMs);
 }
 
-// Checks that there is a delay between input change and margin adaptations.
-TEST(AutomaticGainController2SaturationProtector, AdaptToDelayedChanges) {
-  constexpr int kDelayIterations = kFullBufferSizeMs / kFrameDurationMs;
-  constexpr float kInitialSpeechLevelDbfs = -30.f;
-  constexpr float kLaterSpeechLevelDbfs = -15.f;
+class SaturationProtectorParametrization
+    : public ::testing::TestWithParam<int> {
+ protected:
+  int adjacent_speech_frames_threshold() const { return GetParam(); }
+};
 
-  auto state = CreateSaturationProtectorState();
-  // First run on initial level.
-  float max_difference = RunOnConstantLevel(
-      kDelayIterations, kInitialSpeechLevelDbfs + kInitialMarginDb,
-      kInitialSpeechLevelDbfs, state);
-  // Then peak changes, but not RMS.
-  max_difference =
-      std::max(RunOnConstantLevel(kDelayIterations,
-                                  kLaterSpeechLevelDbfs + kInitialMarginDb,
-                                  kInitialSpeechLevelDbfs, state),
-               max_difference);
-  // Then both change.
-  max_difference =
-      std::max(RunOnConstantLevel(kDelayIterations,
-                                  kLaterSpeechLevelDbfs + kInitialMarginDb,
-                                  kLaterSpeechLevelDbfs, state),
-               max_difference);
-
-  // The saturation protector expects that the RMS changes roughly
-  // 'kFullBufferSizeMs' after peaks change. This is to account for delay
-  // introduced by the level estimator. Therefore, the input above is 'normal'
-  // and 'expected', and shouldn't influence the margin by much.
-  const float total_difference = std::abs(state.margin_db - kInitialMarginDb);
-
-  EXPECT_LE(total_difference, 0.05f);
-  EXPECT_LE(max_difference, 0.01f);
+TEST_P(SaturationProtectorParametrization, DoNotAdaptToShortSpeechSegments) {
+  ApmDataDumper apm_data_dumper(0);
+  auto saturation_protector = CreateSaturationProtector(
+      kInitialHeadroomDb, kNoExtraHeadroomDb,
+      adjacent_speech_frames_threshold(), &apm_data_dumper);
+  const float initial_headroom_db = saturation_protector->HeadroomDb();
+  RunOnConstantLevel(/*num_iterations=*/adjacent_speech_frames_threshold() - 1,
+                     kMaxSpeechProbability,
+                     /*peak_dbfs=*/0.0f,
+                     /*speech_level_dbfs=*/-10.0f, *saturation_protector);
+  // No adaptation expected.
+  EXPECT_EQ(initial_headroom_db, saturation_protector->HeadroomDb());
 }
 
+TEST_P(SaturationProtectorParametrization, AdaptToEnoughSpeechSegments) {
+  ApmDataDumper apm_data_dumper(0);
+  auto saturation_protector = CreateSaturationProtector(
+      kInitialHeadroomDb, kNoExtraHeadroomDb,
+      adjacent_speech_frames_threshold(), &apm_data_dumper);
+  const float initial_headroom_db = saturation_protector->HeadroomDb();
+  RunOnConstantLevel(/*num_iterations=*/adjacent_speech_frames_threshold() + 1,
+                     kMaxSpeechProbability,
+                     /*peak_dbfs=*/0.0f,
+                     /*speech_level_dbfs=*/-10.0f, *saturation_protector);
+  // Adaptation expected.
+  EXPECT_NE(initial_headroom_db, saturation_protector->HeadroomDb());
+}
+
+INSTANTIATE_TEST_SUITE_P(GainController2,
+                         SaturationProtectorParametrization,
+                         ::testing::Values(2, 9, 17));
+
+}  // namespace
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/vad_with_level.cc b/modules/audio_processing/agc2/vad_with_level.cc
index 597c09c..034f2b6 100644
--- a/modules/audio_processing/agc2/vad_with_level.cc
+++ b/modules/audio_processing/agc2/vad_with_level.cc
@@ -65,43 +65,23 @@
   rnn_vad::RnnVad rnn_vad_;
 };
 
-// Returns an updated version of `p_old` by using instant decay and the given
-// `attack` on a new VAD probability value `p_new`.
-float SmoothedVadProbability(float p_old, float p_new, float attack) {
-  RTC_DCHECK_GT(attack, 0.0f);
-  RTC_DCHECK_LE(attack, 1.0f);
-  if (p_new < p_old || attack == 1.0f) {
-    // Instant decay (or no smoothing).
-    return p_new;
-  } else {
-    // Attack phase.
-    return attack * p_new + (1.0f - attack) * p_old;
-  }
-}
-
 }  // namespace
 
 VadLevelAnalyzer::VadLevelAnalyzer()
-    : VadLevelAnalyzer(kDefaultVadRnnResetPeriodMs,
-                       kDefaultSmoothedVadProbabilityAttack,
-                       GetAvailableCpuFeatures()) {}
+    : VadLevelAnalyzer(kDefaultVadRnnResetPeriodMs, GetAvailableCpuFeatures()) {
+}
 
 VadLevelAnalyzer::VadLevelAnalyzer(int vad_reset_period_ms,
-                                   float vad_probability_attack,
                                    const AvailableCpuFeatures& cpu_features)
     : VadLevelAnalyzer(vad_reset_period_ms,
-                       vad_probability_attack,
                        std::make_unique<Vad>(cpu_features)) {}
 
 VadLevelAnalyzer::VadLevelAnalyzer(int vad_reset_period_ms,
-                                   float vad_probability_attack,
                                    std::unique_ptr<VoiceActivityDetector> vad)
     : vad_(std::move(vad)),
       vad_reset_period_frames_(
           rtc::CheckedDivExact(vad_reset_period_ms, kFrameDurationMs)),
-      vad_probability_attack_(vad_probability_attack),
-      time_to_vad_reset_(vad_reset_period_frames_),
-      vad_probability_(0.0f) {
+      time_to_vad_reset_(vad_reset_period_frames_) {
   RTC_DCHECK(vad_);
   RTC_DCHECK_GT(vad_reset_period_frames_, 1);
 }
@@ -123,11 +103,7 @@
     peak = std::max(std::fabs(x), peak);
     rms += x * x;
   }
-  // Compute smoothed speech probability.
-  vad_probability_ = SmoothedVadProbability(
-      /*p_old=*/vad_probability_, /*p_new=*/vad_->ComputeProbability(frame),
-      vad_probability_attack_);
-  return {vad_probability_,
+  return {vad_->ComputeProbability(frame),
           FloatS16ToDbfs(std::sqrt(rms / frame.samples_per_channel())),
           FloatS16ToDbfs(peak)};
 }
diff --git a/modules/audio_processing/agc2/vad_with_level.h b/modules/audio_processing/agc2/vad_with_level.h
index 386f162..7cd93d6 100644
--- a/modules/audio_processing/agc2/vad_with_level.h
+++ b/modules/audio_processing/agc2/vad_with_level.h
@@ -37,18 +37,15 @@
     virtual float ComputeProbability(AudioFrameView<const float> frame) = 0;
   };
 
-  // Ctor. Uses the default VAD.
+  // Ctor. Uses the default VAD with the default settings.
   VadLevelAnalyzer();
   // Ctor. `vad_reset_period_ms` indicates the period in milliseconds to call
   // `VadLevelAnalyzer::Reset()`; it must be equal to or greater than the
-  // duration of two frames. `vad_probability_attack` is a number in (0,1] used
-  // to smooth the speech probability (instant decay, slow attack).
+  // duration of two frames. Uses `cpu_features` to instantiate the default VAD.
   VadLevelAnalyzer(int vad_reset_period_ms,
-                   float vad_probability_attack,
                    const AvailableCpuFeatures& cpu_features);
   // Ctor. Uses a custom `vad`.
   VadLevelAnalyzer(int vad_reset_period_ms,
-                   float vad_probability_attack,
                    std::unique_ptr<VoiceActivityDetector> vad);
 
   VadLevelAnalyzer(const VadLevelAnalyzer&) = delete;
@@ -61,9 +58,7 @@
  private:
   std::unique_ptr<VoiceActivityDetector> vad_;
   const int vad_reset_period_frames_;
-  const float vad_probability_attack_;
   int time_to_vad_reset_;
-  float vad_probability_;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/vad_with_level_unittest.cc b/modules/audio_processing/agc2/vad_with_level_unittest.cc
index fd8265e..99b0136 100644
--- a/modules/audio_processing/agc2/vad_with_level_unittest.cc
+++ b/modules/audio_processing/agc2/vad_with_level_unittest.cc
@@ -29,9 +29,6 @@
 constexpr int kNoVadPeriodicReset =
     kFrameDurationMs * (std::numeric_limits<int>::max() / kFrameDurationMs);
 
-constexpr float kInstantAttack = 1.0f;
-constexpr float kSlowAttack = 0.1f;
-
 constexpr int kSampleRateHz = 8000;
 
 class MockVad : public VadLevelAnalyzer::VoiceActivityDetector {
@@ -48,7 +45,6 @@
 // restart from the beginning.
 std::unique_ptr<VadLevelAnalyzer> CreateVadLevelAnalyzerWithMockVad(
     int vad_reset_period_ms,
-    float vad_probability_attack,
     const std::vector<float>& speech_probabilities,
     int expected_vad_reset_calls = 0) {
   auto vad = std::make_unique<MockVad>();
@@ -58,8 +54,8 @@
   if (expected_vad_reset_calls >= 0) {
     EXPECT_CALL(*vad, Reset).Times(expected_vad_reset_calls);
   }
-  return std::make_unique<VadLevelAnalyzer>(
-      vad_reset_period_ms, vad_probability_attack, std::move(vad));
+  return std::make_unique<VadLevelAnalyzer>(vad_reset_period_ms,
+                                            std::move(vad));
 }
 
 // 10 ms mono frame.
@@ -75,7 +71,7 @@
   const AudioFrameView<const float> view;
 };
 
-TEST(AutomaticGainController2VadLevelAnalyzer, PeakLevelGreaterThanRmsLevel) {
+TEST(GainController2VadLevelAnalyzer, PeakLevelGreaterThanRmsLevel) {
   // Handcrafted frame so that the average is lower than the peak value.
   FrameWithView frame(1000.0f);  // Constant frame.
   frame.samples[10] = 2000.0f;   // Except for one peak value.
@@ -88,14 +84,13 @@
   EXPECT_LT(levels_and_vad_prob.rms_dbfs, levels_and_vad_prob.peak_dbfs);
 }
 
-// Checks that the unprocessed and the smoothed speech probabilities match when
-// instant attack is used.
-TEST(AutomaticGainController2VadLevelAnalyzer, NoSpeechProbabilitySmoothing) {
+// Checks that the expect VAD probabilities are returned.
+TEST(GainController2VadLevelAnalyzer, NoSpeechProbabilitySmoothing) {
   const std::vector<float> speech_probabilities{0.709f, 0.484f, 0.882f, 0.167f,
                                                 0.44f,  0.525f, 0.858f, 0.314f,
                                                 0.653f, 0.965f, 0.413f, 0.0f};
-  auto analyzer = CreateVadLevelAnalyzerWithMockVad(
-      kNoVadPeriodicReset, kInstantAttack, speech_probabilities);
+  auto analyzer = CreateVadLevelAnalyzerWithMockVad(kNoVadPeriodicReset,
+                                                    speech_probabilities);
   FrameWithView frame;
   for (int i = 0; rtc::SafeLt(i, speech_probabilities.size()); ++i) {
     SCOPED_TRACE(i);
@@ -104,45 +99,11 @@
   }
 }
 
-// Checks that the smoothed speech probability does not instantly converge to
-// the unprocessed one when slow attack is used.
-TEST(AutomaticGainController2VadLevelAnalyzer,
-     SlowAttackSpeechProbabilitySmoothing) {
-  const std::vector<float> speech_probabilities{0.0f, 0.0f, 1.0f,
-                                                1.0f, 1.0f, 1.0f};
-  auto analyzer = CreateVadLevelAnalyzerWithMockVad(
-      kNoVadPeriodicReset, kSlowAttack, speech_probabilities);
-  FrameWithView frame;
-  float prev_probability = 0.0f;
-  for (int i = 0; rtc::SafeLt(i, speech_probabilities.size()); ++i) {
-    SCOPED_TRACE(i);
-    const float smoothed_probability =
-        analyzer->AnalyzeFrame(frame.view).speech_probability;
-    EXPECT_LT(smoothed_probability, 1.0f);  // Not enough time to reach 1.
-    EXPECT_LE(prev_probability, smoothed_probability);  // Converge towards 1.
-    prev_probability = smoothed_probability;
-  }
-}
-
-// Checks that the smoothed speech probability instantly decays to the
-// unprocessed one when slow attack is used.
-TEST(AutomaticGainController2VadLevelAnalyzer, SpeechProbabilityInstantDecay) {
-  const std::vector<float> speech_probabilities{1.0f, 1.0f, 1.0f,
-                                                1.0f, 1.0f, 0.0f};
-  auto analyzer = CreateVadLevelAnalyzerWithMockVad(
-      kNoVadPeriodicReset, kSlowAttack, speech_probabilities);
-  FrameWithView frame;
-  for (int i = 0; rtc::SafeLt(i, speech_probabilities.size() - 1); ++i) {
-    analyzer->AnalyzeFrame(frame.view);
-  }
-  EXPECT_EQ(0.0f, analyzer->AnalyzeFrame(frame.view).speech_probability);
-}
-
 // Checks that the VAD is not periodically reset.
-TEST(AutomaticGainController2VadLevelAnalyzer, VadNoPeriodicReset) {
+TEST(GainController2VadLevelAnalyzer, VadNoPeriodicReset) {
   constexpr int kNumFrames = 19;
   auto analyzer = CreateVadLevelAnalyzerWithMockVad(
-      kNoVadPeriodicReset, kSlowAttack, /*speech_probabilities=*/{1.0f},
+      kNoVadPeriodicReset, /*speech_probabilities=*/{1.0f},
       /*expected_vad_reset_calls=*/0);
   FrameWithView frame;
   for (int i = 0; i < kNumFrames; ++i) {
@@ -161,7 +122,7 @@
 TEST_P(VadPeriodResetParametrization, VadPeriodicReset) {
   auto analyzer = CreateVadLevelAnalyzerWithMockVad(
       /*vad_reset_period_ms=*/vad_reset_period_frames() * kFrameDurationMs,
-      kSlowAttack, /*speech_probabilities=*/{1.0f},
+      /*speech_probabilities=*/{1.0f},
       /*expected_vad_reset_calls=*/num_frames() / vad_reset_period_frames());
   FrameWithView frame;
   for (int i = 0; i < num_frames(); ++i) {
@@ -169,7 +130,7 @@
   }
 }
 
-INSTANTIATE_TEST_SUITE_P(AutomaticGainController2VadLevelAnalyzer,
+INSTANTIATE_TEST_SUITE_P(GainController2VadLevelAnalyzer,
                          VadPeriodResetParametrization,
                          ::testing::Combine(::testing::Values(1, 19, 123),
                                             ::testing::Values(2, 5, 20, 53)));
diff --git a/modules/audio_processing/gain_controller2.cc b/modules/audio_processing/gain_controller2.cc
index 6c5e24e..9e3e8e7 100644
--- a/modules/audio_processing/gain_controller2.cc
+++ b/modules/audio_processing/gain_controller2.cc
@@ -73,7 +73,7 @@
 
 void GainController2::NotifyAnalogLevel(int level) {
   if (analog_level_ != level && adaptive_agc_) {
-    adaptive_agc_->Reset();
+    adaptive_agc_->HandleInputGainChange();
   }
   analog_level_ = level;
 }
diff --git a/modules/audio_processing/gain_controller2_unittest.cc b/modules/audio_processing/gain_controller2_unittest.cc
index 274c821..815d58e 100644
--- a/modules/audio_processing/gain_controller2_unittest.cc
+++ b/modules/audio_processing/gain_controller2_unittest.cc
@@ -11,6 +11,7 @@
 #include "modules/audio_processing/gain_controller2.h"
 
 #include <algorithm>
+#include <cmath>
 #include <memory>
 
 #include "api/array_view.h"
@@ -68,7 +69,8 @@
   return agc2;
 }
 
-float GainAfterProcessingFile(GainController2* gain_controller) {
+float GainDbAfterProcessingFile(GainController2& gain_controller,
+                                int max_duration_ms) {
   // Set up an AudioBuffer to be filled from the speech file.
   constexpr size_t kStereo = 2u;
   const StreamConfig capture_config(AudioProcessing::kSampleRate48kHz, kStereo,
@@ -82,24 +84,29 @@
   std::vector<float> capture_input(capture_config.num_frames() *
                                    capture_config.num_channels());
 
-  // The file should contain at least this many frames. Every iteration, we put
-  // a frame through the gain controller.
-  const int kNumFramesToProcess = 100;
-  for (int frame_no = 0; frame_no < kNumFramesToProcess; ++frame_no) {
+  // Process the input file which must be long enough to cover
+  // `max_duration_ms`.
+  RTC_DCHECK_GT(max_duration_ms, 0);
+  const int num_frames = rtc::CheckedDivExact(max_duration_ms, 10);
+  for (int i = 0; i < num_frames; ++i) {
     ReadFloatSamplesFromStereoFile(capture_config.num_frames(),
                                    capture_config.num_channels(), &capture_file,
                                    capture_input);
-
     test::CopyVectorToAudioBuffer(capture_config, capture_input, &ab);
-    gain_controller->Process(&ab);
+    gain_controller.Process(&ab);
   }
 
-  // Send in a last frame with values constant 1 (It's low enough to detect high
-  // gain, and for ease of computation). The applied gain is the result.
+  // Send in a last frame with minimum dBFS level.
   constexpr float sample_value = 1.f;
   SetAudioBufferSamples(sample_value, &ab);
-  gain_controller->Process(&ab);
-  return ab.channels()[0][0];
+  gain_controller.Process(&ab);
+  // Measure the RMS level after processing.
+  float rms = 0.0f;
+  for (size_t i = 0; i < capture_config.num_frames(); ++i) {
+    rms += ab.channels()[0][i] * ab.channels()[0][i];
+  }
+  // Return the applied gain in dB.
+  return 20.0f * std::log10(std::sqrt(rms / capture_config.num_frames()));
 }
 
 }  // namespace
@@ -324,34 +331,20 @@
                                48000,
                                true)));
 
-TEST(GainController2, UsageSaturationMargin) {
+// Checks that the gain applied at the end of a PCM samples file is close to the
+// expected value.
+TEST(GainController2, CheckGainAdaptiveDigital) {
+  constexpr float kExpectedGainDb = 4.3f;
+  constexpr float kToleranceDb = 0.5f;
   GainController2 gain_controller2;
   gain_controller2.Initialize(AudioProcessing::kSampleRate48kHz);
-
   AudioProcessing::Config::GainController2 config;
-  // Check that samples are not amplified as much when extra margin is
-  // high. They should not be amplified at all, but only after convergence. GC2
-  // starts with a gain, and it takes time until it's down to 0 dB.
   config.fixed_digital.gain_db = 0.f;
   config.adaptive_digital.enabled = true;
-  config.adaptive_digital.extra_saturation_margin_db = 50.f;
   gain_controller2.ApplyConfig(config);
-
-  EXPECT_LT(GainAfterProcessingFile(&gain_controller2), 2.f);
-}
-
-TEST(GainController2, UsageNoSaturationMargin) {
-  GainController2 gain_controller2;
-  gain_controller2.Initialize(AudioProcessing::kSampleRate48kHz);
-
-  AudioProcessing::Config::GainController2 config;
-  // Check that some gain is applied if there is no margin.
-  config.fixed_digital.gain_db = 0.f;
-  config.adaptive_digital.enabled = true;
-  config.adaptive_digital.extra_saturation_margin_db = 0.f;
-  gain_controller2.ApplyConfig(config);
-
-  EXPECT_GT(GainAfterProcessingFile(&gain_controller2), 1.9f);
+  EXPECT_NEAR(
+      GainDbAfterProcessingFile(gain_controller2, /*max_duration_ms=*/2000),
+      kExpectedGainDb, kToleranceDb);
 }
 
 }  // namespace test
diff --git a/modules/audio_processing/include/audio_processing.cc b/modules/audio_processing/include/audio_processing.cc
index 790b1a7..fa45230 100644
--- a/modules/audio_processing/include/audio_processing.cc
+++ b/modules/audio_processing/include/audio_processing.cc
@@ -46,17 +46,6 @@
   RTC_CHECK_NOTREACHED();
 }
 
-std::string GainController2LevelEstimatorToString(
-    const Agc2Config::LevelEstimator& level) {
-  switch (level) {
-    case Agc2Config::LevelEstimator::kRms:
-      return "Rms";
-    case Agc2Config::LevelEstimator::kPeak:
-      return "Peak";
-  }
-  RTC_CHECK_NOTREACHED();
-}
-
 std::string GainController2NoiseEstimatorToString(
     const Agc2Config::NoiseEstimator& type) {
   switch (type) {
@@ -174,20 +163,10 @@
       << gain_controller2.adaptive_digital.enabled << ", noise_estimator: "
       << GainController2NoiseEstimatorToString(
              gain_controller2.adaptive_digital.noise_estimator)
-      << ", level_estimator: { vad_probability_attack: "
-      << gain_controller2.adaptive_digital.vad_probability_attack << ", type: "
-      << GainController2LevelEstimatorToString(
-             gain_controller2.adaptive_digital.level_estimator)
+      << ", vad_reset_period_ms: "
+      << gain_controller2.adaptive_digital.vad_reset_period_ms
       << ", adjacent_speech_frames_threshold: "
-      << gain_controller2.adaptive_digital
-             .level_estimator_adjacent_speech_frames_threshold
-      << ", initial_saturation_margin_db: "
-      << gain_controller2.adaptive_digital.initial_saturation_margin_db
-      << ", extra_saturation_margin_db: "
-      << gain_controller2.adaptive_digital.extra_saturation_margin_db
-      << " }, gain_applier: { adjacent_speech_frames_threshold: "
-      << gain_controller2.adaptive_digital
-             .gain_applier_adjacent_speech_frames_threshold
+      << gain_controller2.adaptive_digital.adjacent_speech_frames_threshold
       << ", max_gain_change_db_per_second: "
       << gain_controller2.adaptive_digital.max_gain_change_db_per_second
       << ", max_output_noise_level_dbfs: "
@@ -195,7 +174,7 @@
       << ", sse2_allowed: " << gain_controller2.adaptive_digital.sse2_allowed
       << ", avx2_allowed: " << gain_controller2.adaptive_digital.avx2_allowed
       << ", neon_allowed: " << gain_controller2.adaptive_digital.neon_allowed
-      << " }}}, residual_echo_detector: { enabled: "
+      << "}}, residual_echo_detector: { enabled: "
       << residual_echo_detector.enabled
       << " }, level_estimation: { enabled: " << level_estimation.enabled
       << " }}";
diff --git a/modules/audio_processing/include/audio_processing.h b/modules/audio_processing/include/audio_processing.h
index 781b17e..01bb7c3 100644
--- a/modules/audio_processing/include/audio_processing.h
+++ b/modules/audio_processing/include/audio_processing.h
@@ -349,6 +349,7 @@
         return !(*this == rhs);
       }
 
+      // TODO(crbug.com/webrtc/7494): Remove `LevelEstimator`.
       enum LevelEstimator { kRms, kPeak };
       enum NoiseEstimator { kStationaryNoise, kNoiseFloor };
       bool enabled = false;
@@ -359,19 +360,20 @@
         bool enabled = false;
         NoiseEstimator noise_estimator = kNoiseFloor;
         int vad_reset_period_ms = 1500;
-        float vad_probability_attack = 0.9f;
-        LevelEstimator level_estimator = kRms;
-        int level_estimator_adjacent_speech_frames_threshold = 11;
-        // TODO(crbug.com/webrtc/7494): Remove `use_saturation_protector`.
-        bool use_saturation_protector = true;
-        float initial_saturation_margin_db = 20.0f;
-        float extra_saturation_margin_db = 5.0f;
-        int gain_applier_adjacent_speech_frames_threshold = 11;
+        int adjacent_speech_frames_threshold = 12;
         float max_gain_change_db_per_second = 3.0f;
-        float max_output_noise_level_dbfs = -55.0f;
+        float max_output_noise_level_dbfs = -50.0f;
         bool sse2_allowed = true;
         bool avx2_allowed = true;
         bool neon_allowed = true;
+        // TODO(crbug.com/webrtc/7494): Remove deprecated settings below.
+        float vad_probability_attack = 1.0f;
+        LevelEstimator level_estimator = kRms;
+        int level_estimator_adjacent_speech_frames_threshold = 12;
+        bool use_saturation_protector = true;
+        float initial_saturation_margin_db = 25.0f;
+        float extra_saturation_margin_db = 5.0f;
+        int gain_applier_adjacent_speech_frames_threshold = 12;
       } adaptive_digital;
     } gain_controller2;