AGC2 dummy module: fixed gain param, APM integration, audioproc_f adaptation

webrtc/modules/audio_processing/audio_processing_impl.cc

 /*
  *  Copyright (c) 2012 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 232 matching lines @@
 bool AudioProcessingImpl::ApmSubmoduleStates::CaptureMultiBandProcessingActive()
     const {
   return low_cut_filter_enabled_ || echo_canceller_enabled_ ||
          mobile_echo_controller_enabled_ || noise_suppressor_enabled_ ||
          beamformer_enabled_ || adaptive_gain_controller_enabled_ ||
          echo_canceller3_enabled_;
 }
 
 bool AudioProcessingImpl::ApmSubmoduleStates::CaptureFullBandProcessingActive()
     const {
-  return level_controller_enabled_;
+  return level_controller_enabled_ && gain_controller2_enabled_;
 }
 
 bool AudioProcessingImpl::ApmSubmoduleStates::RenderMultiBandSubModulesActive()
     const {
   return RenderMultiBandProcessingActive() || echo_canceller_enabled_ ||
          mobile_echo_controller_enabled_ || adaptive_gain_controller_enabled_ ||
          echo_canceller3_enabled_;
 }
 
 bool AudioProcessingImpl::ApmSubmoduleStates::RenderMultiBandProcessingActive()
@@ skipping 100 matching lines @@
         new VoiceDetectionImpl(&crit_capture_));
     public_submodules_->gain_control_for_experimental_agc.reset(
         new GainControlForExperimentalAgc(
             public_submodules_->gain_control.get(), &crit_capture_));
     private_submodules_->residual_echo_detector.reset(
         new ResidualEchoDetector());
 
     // TODO(peah): Move this creation to happen only when the level controller
     // is enabled.
     private_submodules_->level_controller.reset(new LevelController());
+
+    // TODO(alessiob): Move this creation to happen only when the gain
+    // controller is enabled.

[AleBzk, 2017/09/14 09:21:56]

@Per: I replicated the TODO from LC, but the code below will change when we will
have AGC injection.

[peah-webrtc, 2017/09/15 07:44:25]

Acknowledged.

[AleBzk, 2017/09/29 09:39:06]

Done.

+    private_submodules_->gain_controller2.reset(new GainController2());
   }
 
   SetExtraOptions(config);
 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
   // Depends on gain_control_ and
   // public_submodules_->gain_control_for_experimental_agc.
   private_submodules_->agc_manager.reset();
   // Depends on gain_control_.
@@ skipping 285 matching lines @@
 
   if (config.echo_canceller3.enabled !=
       capture_nonlocked_.echo_canceller3_enabled) {
     capture_nonlocked_.echo_canceller3_enabled =
         config_.echo_canceller3.enabled;
     InitializeEchoCanceller3();
     LOG(LS_INFO) << "Echo canceller 3 activated: "
                  << capture_nonlocked_.echo_canceller3_enabled;
   }
 
-  config_ok = GainController2::Validate(config_.gain_controller2);
-  if (!config_ok) {
+  if (!GainController2::Validate(config_.gain_controller2)) {

[peah-webrtc, 2017/09/15 07:44:25]

Even though this works, I think it makes sense to follow the same pattern as
above, and not change this from how it was before.

I'm not sure of the background to why it is like that, but I think it is to
simplify debugging using a debugger.

[AleBzk, 2017/09/29 09:39:06]

Done.

     LOG(LS_ERROR) << "AudioProcessing module config error" << std::endl
-                  << "gain_controller2: "
+                  << "Gain Controller 2: "
                   << GainController2::ToString(config_.gain_controller2)
                   << std::endl
                   << "Reverting to default parameter set";
     config_.gain_controller2 = AudioProcessing::Config::GainController2();
   }
-
-  if (config.gain_controller2.enabled !=
-      capture_nonlocked_.gain_controller2_enabled) {
-    capture_nonlocked_.gain_controller2_enabled =
-        config_.gain_controller2.enabled;
-    InitializeGainController2();
-    LOG(LS_INFO) << "Gain controller 2 activated: "
-                 << capture_nonlocked_.gain_controller2_enabled;
-  }
+  InitializeGainController2();

[AleBzk, 2017/09/14 09:21:56]

@Per: every time that we call AudioProcessingImpl::ApplyConfig we both call
Initialize() and ApplyConfig() on the active APM sub-modules. But when we call
AudioProcessingImpl::Initialize() we only call Initialize() on the active APM
sub-modules. is this right in general?

[peah-webrtc, 2017/09/15 07:44:25]

I think so.

+  private_submodules_->gain_controller2->ApplyConfig(config_.gain_controller2);
+  LOG(LS_INFO) << "Gain Controller 2 activated: "
+               << config_.gain_controller2.enabled;
 }
 
 void AudioProcessingImpl::SetExtraOptions(const webrtc::Config& config) {
   // Run in a single-threaded manner when setting the extra options.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
 
   public_submodules_->echo_cancellation->SetExtraOptions(config);
 
   if (capture_.transient_suppressor_enabled !=
@@ skipping 556 matching lines @@
 
     public_submodules_->transient_suppressor->Suppress(
         capture_buffer->channels_f()[0], capture_buffer->num_frames(),
         capture_buffer->num_channels(),
         capture_buffer->split_bands_const_f(0)[kBand0To8kHz],
         capture_buffer->num_frames_per_band(), capture_buffer->keyboard_data(),
         capture_buffer->num_keyboard_frames(), voice_probability,
         capture_.key_pressed);
   }
 
-  if (capture_nonlocked_.gain_controller2_enabled) {
+  if (config_.gain_controller2.enabled) {
     private_submodules_->gain_controller2->Process(capture_buffer);
   }
 
   if (capture_nonlocked_.level_controller_enabled) {
     private_submodules_->level_controller->Process(capture_buffer);
   }
 
   // The level estimator operates on the recombined data.
   public_submodules_->level_estimator->ProcessStream(capture_buffer);
 
@@ skipping 327 matching lines @@
 bool AudioProcessingImpl::UpdateActiveSubmoduleStates() {
   return submodule_states_.Update(
       config_.high_pass_filter.enabled,
       public_submodules_->echo_cancellation->is_enabled(),
       public_submodules_->echo_control_mobile->is_enabled(),
       config_.residual_echo_detector.enabled,
       public_submodules_->noise_suppression->is_enabled(),
       capture_nonlocked_.intelligibility_enabled,
       capture_nonlocked_.beamformer_enabled,
       public_submodules_->gain_control->is_enabled(),
-      capture_nonlocked_.gain_controller2_enabled,
+      config_.gain_controller2.enabled,
       capture_nonlocked_.level_controller_enabled,
       capture_nonlocked_.echo_canceller3_enabled,
       public_submodules_->voice_detection->is_enabled(),
       public_submodules_->level_estimator->is_enabled(),
       capture_.transient_suppressor_enabled);
 }
 
 
 void AudioProcessingImpl::InitializeTransient() {
   if (capture_.transient_suppressor_enabled) {
@@ skipping 41 matching lines @@
 void AudioProcessingImpl::InitializeEchoCanceller3() {
   if (capture_nonlocked_.echo_canceller3_enabled) {
     private_submodules_->echo_canceller3.reset(new EchoCanceller3(
         config_.echo_canceller3, proc_sample_rate_hz(), true));
   } else {
     private_submodules_->echo_canceller3.reset();
   }
 }
 
 void AudioProcessingImpl::InitializeGainController2() {
-  if (capture_nonlocked_.gain_controller2_enabled) {
-    private_submodules_->gain_controller2.reset(
-        new GainController2(proc_sample_rate_hz()));
-  } else {
-    private_submodules_->gain_controller2.reset();
+  if (config_.gain_controller2.enabled) {
+    private_submodules_->gain_controller2->Initialize(proc_sample_rate_hz());
   }
 }
 
 void AudioProcessingImpl::InitializeLevelController() {
   private_submodules_->level_controller->Initialize(proc_sample_rate_hz());
 }
 
 void AudioProcessingImpl::InitializeResidualEchoDetector() {
   private_submodules_->residual_echo_detector->Initialize();
 }
 
 void AudioProcessingImpl::MaybeUpdateHistograms() {
   static const int kMinDiffDelayMs = 60;
 
   if (echo_cancellation()->is_enabled()) {
-    // Activate delay_jumps_ counters if we know echo_cancellation is runnning.
+    // Activate delay_jumps_ counters if we know echo_cancellation is running.
     // If a stream has echo we know that the echo_cancellation is in process.
     if (capture_.stream_delay_jumps == -1 &&
         echo_cancellation()->stream_has_echo()) {
       capture_.stream_delay_jumps = 0;
     }
     if (capture_.aec_system_delay_jumps == -1 &&
         echo_cancellation()->stream_has_echo()) {
       capture_.aec_system_delay_jumps = 0;
     }
 
@@ skipping 65 matching lines @@
   // descriptions for other submodules.
   if (capture_nonlocked_.level_controller_enabled) {
     experiments_description += "LevelController;";
   }
   if (constants_.agc_clipped_level_min != kClippedLevelMin) {
     experiments_description += "AgcClippingLevelExperiment;";
   }
   if (capture_nonlocked_.echo_canceller3_enabled) {
     experiments_description += "EchoCanceller3;";
   }
+  if (config_.gain_controller2.enabled) {
+    experiments_description += "GainController2;";
+  }
 
   InternalAPMConfig apm_config;
 
   apm_config.aec_enabled = public_submodules_->echo_cancellation->is_enabled();
   apm_config.aec_delay_agnostic_enabled =
       public_submodules_->echo_cancellation->is_delay_agnostic_enabled();
   apm_config.aec_drift_compensation_enabled =
       public_submodules_->echo_cancellation->is_drift_compensation_enabled();
   apm_config.aec_extended_filter_enabled =
       public_submodules_->echo_cancellation->is_extended_filter_enabled();
@@ skipping 104 matching lines @@
       split_rate(kSampleRate16kHz),
       echo_path_gain_change(false) {}
 
 AudioProcessingImpl::ApmCaptureState::~ApmCaptureState() = default;
 
 AudioProcessingImpl::ApmRenderState::ApmRenderState() = default;
 
 AudioProcessingImpl::ApmRenderState::~ApmRenderState() = default;
 
 }  // namespace webrtc