Reland of added functionality for specifying the initial signal level to use for the gain estimation

webrtc/modules/audio_processing/level_controller/level_controller.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.
  */
 
@@ skipping 163 matching lines @@
                  << "Last frame peak level:        " << frame_peak_level_dbfs
                  << " dBFS";
 
     Reset();
   }
 }
 
 LevelController::LevelController()
     : data_dumper_(new ApmDataDumper(instance_count_)),
       gain_applier_(data_dumper_.get()),
-      signal_classifier_(data_dumper_.get()) {
+      signal_classifier_(data_dumper_.get()),
+      peak_level_estimator_(kTargetLcPeakLeveldBFS) {
   Initialize(AudioProcessing::kSampleRate48kHz);
   ++instance_count_;
 }
 
 LevelController::~LevelController() {}
 
 void LevelController::Initialize(int sample_rate_hz) {
   RTC_DCHECK(sample_rate_hz == AudioProcessing::kSampleRate8kHz ||
              sample_rate_hz == AudioProcessing::kSampleRate16kHz ||
              sample_rate_hz == AudioProcessing::kSampleRate32kHz ||
              sample_rate_hz == AudioProcessing::kSampleRate48kHz);
   data_dumper_->InitiateNewSetOfRecordings();
   gain_selector_.Initialize(sample_rate_hz);
   gain_applier_.Initialize(sample_rate_hz);
   signal_classifier_.Initialize(sample_rate_hz);
   noise_level_estimator_.Initialize(sample_rate_hz);
-  peak_level_estimator_.Initialize();
+  peak_level_estimator_.Initialize(config_.initial_peak_level_dbfs);
   saturating_gain_estimator_.Initialize();
   metrics_.Initialize(sample_rate_hz);
 
   last_gain_ = 1.0f;
   sample_rate_hz_ = rtc::Optional<int>(sample_rate_hz);
   dc_forgetting_factor_ = 0.01f * sample_rate_hz / 48000.f;
   std::fill(dc_level_, dc_level_ + arraysize(dc_level_), 0.f);
 }
 
 void LevelController::Process(AudioBuffer* audio) {
@@ skipping 21 matching lines @@
       noise_level_estimator_.Analyze(signal_type, FrameEnergy(*audio));
 
   // Estimate the overall signal peak level.
   const float frame_peak_level = PeakLevel(*audio);
   const float long_term_peak_level =
       peak_level_estimator_.Analyze(signal_type, frame_peak_level);
 
   float saturating_gain = saturating_gain_estimator_.GetGain();
 
   // Compute the new gain to apply.
-  last_gain_ = gain_selector_.GetNewGain(long_term_peak_level, noise_energy,
-                                         saturating_gain, signal_type);
+  last_gain_ =
+      gain_selector_.GetNewGain(long_term_peak_level, noise_energy,
+                                saturating_gain, gain_jumpstart_, signal_type);
+
+  // Unflag the jumpstart of the gain as it should only happen once.
+  gain_jumpstart_ = false;
 
   // Apply the gain to the signal.
   int num_saturations = gain_applier_.Process(last_gain_, audio);
 
   // Estimate the gain that saturates the overall signal.
   saturating_gain_estimator_.Update(last_gain_, num_saturations);
 
   // Update the metrics.
   metrics_.Update(long_term_peak_level, noise_energy, last_gain_,
                   frame_peak_level);
 
   data_dumper_->DumpRaw("lc_selected_gain", 1, &last_gain_);
   data_dumper_->DumpRaw("lc_noise_energy", 1, &noise_energy);
   data_dumper_->DumpRaw("lc_peak_level", 1, &long_term_peak_level);
   data_dumper_->DumpRaw("lc_saturating_gain", 1, &saturating_gain);
 
   data_dumper_->DumpWav("lc_output", audio->num_frames(),
                         audio->channels_f()[0], *sample_rate_hz_, 1);
 }
 
+void LevelController::ApplyConfig(
+    const AudioProcessing::Config::LevelController& config) {
+  RTC_DCHECK(Validate(config));
+  config_ = config;
+  peak_level_estimator_.Initialize(config_.initial_peak_level_dbfs);
+  gain_jumpstart_ = true;
+}
+
 std::string LevelController::ToString(
     const AudioProcessing::Config::LevelController& config) {
   std::stringstream ss;
   ss << "{"
-     << "enabled: " << (config.enabled ? "true" : "false") << "}";
+     << "enabled: " << (config.enabled ? "true" : "false") << ", "
+     << "initial_peak_level_dbfs: " << config.initial_peak_level_dbfs << "}";
   return ss.str();
 }
 
 bool LevelController::Validate(
     const AudioProcessing::Config::LevelController& config) {
-  return true;
+  return (config.initial_peak_level_dbfs <
+              std::numeric_limits<float>::epsilon() &&
+          config.initial_peak_level_dbfs >
+              -(100.f + std::numeric_limits<float>::epsilon()));
 }
 
 }  // namespace webrtc