Add SafeClamp(), which accepts args of different types

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/base/logging.h"
+#include "webrtc/base/safe_minmax.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/metrics.h"
 
 namespace webrtc {
 
 namespace {
 
 // Amount the microphone level is lowered with every clipping event.
@@ skipping 18 matching lines @@
 const int kMinMicLevel = 12;
 
 // Prevent very large microphone level changes.
 const int kMaxResidualGainChange = 15;
 
 // Maximum additional gain allowed to compensate for microphone level
 // restrictions from clipping events.
 const int kSurplusCompressionGain = 6;
 
 int ClampLevel(int mic_level) {
-  return std::min(std::max(kMinMicLevel, mic_level), kMaxMicLevel);
+  return rtc::SafeClamp(mic_level, kMinMicLevel, kMaxMicLevel);
 }
 
 int LevelFromGainError(int gain_error, int level) {
   RTC_DCHECK_GE(level, 0);
   RTC_DCHECK_LE(level, kMaxMicLevel);
   if (gain_error == 0) {
     return level;
   }
   // TODO(ajm): Could be made more efficient with a binary search.
   int new_level = level;
@@ skipping 303 matching lines @@
   if (!agc_->GetRmsErrorDb(&rms_error)) {
     // No error update ready.
     return;
   }
   // The compressor will always add at least kMinCompressionGain. In effect,
   // this adjusts our target gain upward by the same amount and rms_error
   // needs to reflect that.
   rms_error += kMinCompressionGain;
 
   // Handle as much error as possible with the compressor first.
-  int raw_compression = std::max(std::min(rms_error, max_compression_gain_),
-                                 kMinCompressionGain);
+  int raw_compression =
+      rtc::SafeClamp(rms_error, kMinCompressionGain, max_compression_gain_);
+
   // Deemphasize the compression gain error. Move halfway between the current
   // target and the newly received target. This serves to soften perceptible
   // intra-talkspurt adjustments, at the cost of some adaptation speed.
   if ((raw_compression == max_compression_gain_ &&
       target_compression_ == max_compression_gain_ - 1) ||
       (raw_compression == kMinCompressionGain &&
       target_compression_ == kMinCompressionGain + 1)) {
     // Special case to allow the target to reach the endpoints of the
     // compression range. The deemphasis would otherwise halt it at 1 dB shy.
     target_compression_ = raw_compression;
   } else {
     target_compression_ = (raw_compression - target_compression_) / 2
         + target_compression_;
   }
 
   // Residual error will be handled by adjusting the volume slider. Use the
   // raw rather than deemphasized compression here as we would otherwise
   // shrink the amount of slack the compressor provides.
-  int residual_gain = rms_error - raw_compression;
-  residual_gain = std::min(std::max(residual_gain, -kMaxResidualGainChange),
-      kMaxResidualGainChange);
+  const int residual_gain =
+      rtc::SafeClamp(rms_error - raw_compression, -kMaxResidualGainChange,
+                     kMaxResidualGainChange);
   LOG(LS_INFO) << "[agc] rms_error=" << rms_error << ", "
                << "target_compression=" << target_compression_ << ", "
                << "residual_gain=" << residual_gain;
   if (residual_gain == 0)
     return;
 
   int old_level = level_;
   SetLevel(LevelFromGainError(residual_gain, level_));
   if (old_level != level_) {
     // level_ was updated by SetLevel; log the new value.
@@ skipping 30 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