Added functionality for specifying the initial signal level to use for the gain estimation in the l…

webrtc/modules/audio_processing/level_controller/peak_level_estimator.cc

 /*
  *  Copyright (c) 2016 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/level_controller/peak_level_estimator.h"
 
 #include <algorithm>
 
 #include "webrtc/modules/audio_processing/audio_buffer.h"
-#include "webrtc/modules/audio_processing/level_controller/lc_constants.h"
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
 
 namespace webrtc {
+namespace {
+
+const float kMinLevel = 30.f;
+
+}  // namespace
 
 PeakLevelEstimator::PeakLevelEstimator() {
   Initialize();
 }
 
 PeakLevelEstimator::~PeakLevelEstimator() {}
 
 void PeakLevelEstimator::Initialize() {
-  peak_level_ = kTargetLcPeakLevel;
+  peak_level_ = initial_peak_level_;
   hold_counter_ = 0;
   initialization_phase_ = true;
 }
 
+void PeakLevelEstimator::SetInitialPeakLevel(float level) {
+  RTC_DCHECK_LE(-100.f, level);
+  RTC_DCHECK_GE(0.f, level);
+
+  float linear_level = std::pow(10.f, level / 20.f) * 32768.f;
+
+  // Limit the supplied level to the level range used internally.
+  initial_peak_level_ = std::max(linear_level, kMinLevel);
+  Initialize();
+}
+
 float PeakLevelEstimator::Analyze(SignalClassifier::SignalType signal_type,
                                   float frame_peak_level) {
   if (frame_peak_level == 0) {
-    RTC_DCHECK_LE(30.f, peak_level_);
+    RTC_DCHECK_LE(kMinLevel, peak_level_);
     return peak_level_;
   }
 
   if (peak_level_ < frame_peak_level) {
     // Smoothly update the estimate upwards when the frame peak level is
     // higher than the estimate.
     peak_level_ += 0.1f * (frame_peak_level - peak_level_);

[the sun, 2016/08/23 06:23:38]

Sanity check: this calculation means that peak_level_ never contains the actual
peak level. The filtered average will lag behind the true dynamics of the
signal. But I guess that is the intention?

[peah-webrtc, 2016/08/26 10:47:13]

Yes, that is the intention. It should be more of a long-term value than the
instantaneous value.

     hold_counter_ = 100;
     initialization_phase_ = false;
   } else {
     hold_counter_ = std::max(0, hold_counter_ - 1);
 
     // When the signal is highly non-stationary, update the estimate slowly
     // downwards if the estimate is lower than the frame peak level.
     if ((signal_type == SignalClassifier::SignalType::kHighlyNonStationary &&
          hold_counter_ == 0) ||
         initialization_phase_) {
       peak_level_ =
           std::max(peak_level_ + 0.01f * (frame_peak_level - peak_level_),
                    peak_level_ * 0.995f);
     }
   }
 
-  peak_level_ = std::max(peak_level_, 30.f);
+  peak_level_ = std::max(peak_level_, kMinLevel);
 
   return peak_level_;
 }
 
 }  // namespace webrtc