AGC: Route clipping parameter from webrtc::Config to AGC

webrtc/modules/audio_processing/agc/agc_manager_direct.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/modules/audio_processing/agc/agc_manager_direct.h"
 
 #include <cmath>
 
 #ifdef WEBRTC_AGC_DEBUG_DUMP
 #include <cstdio>
 #endif
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_processing/agc/gain_map_internal.h"
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
 namespace {
 
-// Lowest the microphone level can be lowered due to clipping.
-const int kClippedLevelMin = 170;
 // Amount the microphone level is lowered with every clipping event.
 const int kClippedLevelStep = 15;
 // Proportion of clipped samples required to declare a clipping event.
 const float kClippedRatioThreshold = 0.1f;
 // Time in frames to wait after a clipping event before checking again.
 const int kClippedWaitFrames = 300;
 
 // Amount of error we tolerate in the microphone level (presumably due to OS
 // quantization) before we assume the user has manually adjusted the microphone.
 const int kLevelQuantizationSlack = 25;
@@ skipping 66 matching lines @@
   }
   ~DebugFile() {
   }
   void Write(const int16_t* data, size_t length_samples) {
   }
 #endif  // WEBRTC_AGC_DEBUG_DUMP
 };
 
 AgcManagerDirect::AgcManagerDirect(GainControl* gctrl,
                                    VolumeCallbacks* volume_callbacks,
-                                   int startup_min_level)
+                                   int startup_min_level,
+                                   int clipped_level_min)
     : agc_(new Agc()),
       gctrl_(gctrl),
       volume_callbacks_(volume_callbacks),
       frames_since_clipped_(kClippedWaitFrames),
       level_(0),
       max_level_(kMaxMicLevel),
       max_compression_gain_(kMaxCompressionGain),
       target_compression_(kDefaultCompressionGain),
       compression_(target_compression_),
       compression_accumulator_(compression_),
       capture_muted_(false),
       check_volume_on_next_process_(true),  // Check at startup.
       startup_(true),
       startup_min_level_(ClampLevel(startup_min_level)),
+      clipped_level_min_(clipped_level_min),
       file_preproc_(new DebugFile("agc_preproc.pcm")),
-      file_postproc_(new DebugFile("agc_postproc.pcm")) {
-}
+      file_postproc_(new DebugFile("agc_postproc.pcm")) {}
 
 AgcManagerDirect::AgcManagerDirect(Agc* agc,
                                    GainControl* gctrl,
                                    VolumeCallbacks* volume_callbacks,
-                                   int startup_min_level)
+                                   int startup_min_level,
+                                   int clipped_level_min)
     : agc_(agc),
       gctrl_(gctrl),
       volume_callbacks_(volume_callbacks),
       frames_since_clipped_(kClippedWaitFrames),
       level_(0),
       max_level_(kMaxMicLevel),
       max_compression_gain_(kMaxCompressionGain),
       target_compression_(kDefaultCompressionGain),
       compression_(target_compression_),
       compression_accumulator_(compression_),
       capture_muted_(false),
       check_volume_on_next_process_(true),  // Check at startup.
       startup_(true),
       startup_min_level_(ClampLevel(startup_min_level)),
+      clipped_level_min_(clipped_level_min),
       file_preproc_(new DebugFile("agc_preproc.pcm")),
-      file_postproc_(new DebugFile("agc_postproc.pcm")) {
-}
+      file_postproc_(new DebugFile("agc_postproc.pcm")) {}
 
 AgcManagerDirect::~AgcManagerDirect() {}
 
 int AgcManagerDirect::Initialize() {
   max_level_ = kMaxMicLevel;
   max_compression_gain_ = kMaxCompressionGain;
   target_compression_ = kDefaultCompressionGain;
   compression_ = target_compression_;
   compression_accumulator_ = compression_;
   capture_muted_ = false;
@@ skipping 43 matching lines @@
   // and enforce a new maximum level, dropped the same amount from the current
   // maximum. This harsh treatment is an effort to avoid repeated clipped echo
   // events. As compensation for this restriction, the maximum compression
   // gain is increased, through SetMaxLevel().
   float clipped_ratio = agc_->AnalyzePreproc(audio, length);
   if (clipped_ratio > kClippedRatioThreshold) {
     LOG(LS_INFO) << "[agc] Clipping detected. clipped_ratio="
                  << clipped_ratio;
     // Always decrease the maximum level, even if the current level is below
     // threshold.
-    SetMaxLevel(std::max(kClippedLevelMin, max_level_ - kClippedLevelStep));
+    SetMaxLevel(std::max(clipped_level_min_, max_level_ - kClippedLevelStep));
     RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.AgcClippingAdjustmentAllowed",
-                          level_ - kClippedLevelStep >= kClippedLevelMin);
-    if (level_ > kClippedLevelMin) {
+                          level_ - kClippedLevelStep >= clipped_level_min_);
+    if (level_ > clipped_level_min_) {
       // Don't try to adjust the level if we're already below the limit. As
       // a consequence, if the user has brought the level above the limit, we
       // will still not react until the postproc updates the level.
-      SetLevel(std::max(kClippedLevelMin, level_ - kClippedLevelStep));
+      SetLevel(std::max(clipped_level_min_, level_ - kClippedLevelStep));
       // Reset the AGC since the level has changed.
       agc_->Reset();
     }
     frames_since_clipped_ = 0;
   }
 }
 
 void AgcManagerDirect::Process(const int16_t* audio,
                                size_t length,
                                int sample_rate_hz) {
@@ skipping 55 matching lines @@
   }
 
   volume_callbacks_->SetMicVolume(new_level);
   LOG(LS_INFO) << "[agc] voe_level=" << voe_level << ", "
                << "level_=" << level_ << ", "
                << "new_level=" << new_level;
   level_ = new_level;
 }
 
 void AgcManagerDirect::SetMaxLevel(int level) {
-  RTC_DCHECK_GE(level, kClippedLevelMin);
+  RTC_DCHECK_GE(level, clipped_level_min_);
   max_level_ = level;
   // Scale the |kSurplusCompressionGain| linearly across the restricted
   // level range.
-  max_compression_gain_ = kMaxCompressionGain + std::floor(
-      (1.f * kMaxMicLevel - max_level_) / (kMaxMicLevel - kClippedLevelMin) *
-      kSurplusCompressionGain + 0.5f);
+  max_compression_gain_ =
+      kMaxCompressionGain + std::floor((1.f * kMaxMicLevel - max_level_) /
+                                           (kMaxMicLevel - clipped_level_min_) *
+                                           kSurplusCompressionGain +
+                                       0.5f);
   LOG(LS_INFO) << "[agc] max_level_=" << max_level_
                << ", max_compression_gain_="  << max_compression_gain_;
 }
 
 void AgcManagerDirect::SetCaptureMuted(bool muted) {
   if (capture_muted_ == muted) {
     return;
   }
   capture_muted_ = muted;
 
@@ skipping 122 matching lines @@
     compression_ = new_compression;
     compression_accumulator_ = new_compression;
     if (gctrl_->set_compression_gain_db(compression_) != 0) {
       LOG(LS_ERROR) << "set_compression_gain_db(" << compression_
                     << ") failed.";
     }
   }
 }
 
 }  // namespace webrtc