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;
+const float kMaxLevel = 32768.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(0.f, level);
+  RTC_DCHECK_GE(32768.f, level);

[the sun, 2016/08/22 11:58:22]

Why not use the constants here?

[peah-webrtc, 2016/08/22 12:09:04]

That is a good question:

The thinking was like this:
-I don't want to complicate that APM API by imposing a complicated level
requirement, so therefore I basically chose the full range.
-If the internal range, e.g., currently 30.0f-32768.0f would change (for reasons
of adjusting the performance, it is nice not to have to change the API because
of that for that.
-If I DCHECK on the internal range, that would cause valid input data (according
to the API description) to cause DCHECKS, which does not make sense.

[the sun, 2016/08/22 14:18:39]

Ok that makes sense, but when I think about it, 0 dBFS in is usually 1.0 in the
floating point world, so from that perspective, the limits here appear a bit
random.
I think you need to explain that to me in person. :)
Agree.

[peah-webrtc, 2016/08/23 05:33:44]

You are right! Excellent point. 

I changed the API to instead receive the level in dBFS with a specified range of
[-100, 0]. What do you think of that solution?

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

Nice, I would have gone for range 0-1.0 myself, but this is even better. Unless,
of course, if this method is called often, which I guess it wouldn't be?

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

That is correct, this is not something that will happen often.

+
+  // Limit the supplied level to the level range used internally.
+  initial_peak_level_ = std::min(std::max(level, kMinLevel), kMaxLevel);

[the sun, 2016/08/22 11:58:22]

Do you really need to DCHECK as well as clamp?

[peah-webrtc, 2016/08/22 12:09:04]

That is a good question. Please see above response for the answer.

[the sun, 2016/08/22 14:18:39]

Right. I think generally APIs should aggressively assert the specified contract,
as you say. In this case you should only need the std::max() to limit the range
though.

[peah-webrtc, 2016/08/23 05:33:44]

True, I removed the std::min.

Done.

+  Initialize();
+}
+
 float PeakLevelEstimator::Analyze(SignalClassifier::SignalType signal_type,
                                   float frame_peak_level) {
   if (frame_peak_level == 0) {
     RTC_DCHECK_LE(30.f, peak_level_);

[the sun, 2016/08/22 11:58:22]

Should this be kMinLevel?

[peah-webrtc, 2016/08/23 05:33:44]

Done.

     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_);
     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);
 
   return peak_level_;
 }
 
 }  // namespace webrtc