Moved the GainControlForNewAGC class to a separate file.

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 11 matching lines @@
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 extern "C" {
 #include "webrtc/modules/audio_processing/aec/aec_core.h"
 }
 #include "webrtc/modules/audio_processing/agc/agc_manager_direct.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #include "webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.h"
 #include "webrtc/modules/audio_processing/common.h"
 #include "webrtc/modules/audio_processing/echo_cancellation_impl.h"
 #include "webrtc/modules/audio_processing/echo_control_mobile_impl.h"
+#include "webrtc/modules/audio_processing/gain_control_for_experimental_agc.h"
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 #include "webrtc/modules/audio_processing/high_pass_filter_impl.h"
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h"
 #include "webrtc/modules/audio_processing/level_estimator_impl.h"
 #include "webrtc/modules/audio_processing/noise_suppression_impl.h"
 #include "webrtc/modules/audio_processing/processing_component.h"
 #include "webrtc/modules/audio_processing/transient/transient_suppressor.h"
 #include "webrtc/modules/audio_processing/voice_detection_impl.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
@@ skipping 31 matching lines @@
   }
 
   assert(false);
   return false;
 }
 }  // namespace
 
 // Throughout webrtc, it's assumed that success is represented by zero.
 static_assert(AudioProcessing::kNoError == 0, "kNoError must be zero");
 
-// This class has two main functionalities:
-//
-// 1) It is returned instead of the real GainControl after the new AGC has been
-//    enabled in order to prevent an outside user from overriding compression
-//    settings. It doesn't do anything in its implementation, except for
-//    delegating the const methods and Enable calls to the real GainControl, so
-//    AGC can still be disabled.
-//
-// 2) It is injected into AgcManagerDirect and implements volume callbacks for
-//    getting and setting the volume level. It just caches this value to be used
-//    in VoiceEngine later.
-class GainControlForNewAgc : public GainControl, public VolumeCallbacks {
- public:
-  explicit GainControlForNewAgc(GainControlImpl* gain_control)
-      : real_gain_control_(gain_control), volume_(0) {}
-
-  // GainControl implementation.
-  int Enable(bool enable) override {
-    return real_gain_control_->Enable(enable);
-  }
-  bool is_enabled() const override { return real_gain_control_->is_enabled(); }
-  int set_stream_analog_level(int level) override {
-    volume_ = level;
-    return AudioProcessing::kNoError;
-  }
-  int stream_analog_level() override { return volume_; }
-  int set_mode(Mode mode) override { return AudioProcessing::kNoError; }
-  Mode mode() const override { return GainControl::kAdaptiveAnalog; }
-  int set_target_level_dbfs(int level) override {
-    return AudioProcessing::kNoError;
-  }
-  int target_level_dbfs() const override {
-    return real_gain_control_->target_level_dbfs();
-  }
-  int set_compression_gain_db(int gain) override {
-    return AudioProcessing::kNoError;
-  }
-  int compression_gain_db() const override {
-    return real_gain_control_->compression_gain_db();
-  }
-  int enable_limiter(bool enable) override { return AudioProcessing::kNoError; }
-  bool is_limiter_enabled() const override {
-    return real_gain_control_->is_limiter_enabled();
-  }
-  int set_analog_level_limits(int minimum, int maximum) override {
-    return AudioProcessing::kNoError;
-  }
-  int analog_level_minimum() const override {
-    return real_gain_control_->analog_level_minimum();
-  }
-  int analog_level_maximum() const override {
-    return real_gain_control_->analog_level_maximum();
-  }
-  bool stream_is_saturated() const override {
-    return real_gain_control_->stream_is_saturated();
-  }
-
-  // VolumeCallbacks implementation.
-  void SetMicVolume(int volume) override { volume_ = volume; }
-  int GetMicVolume() override { return volume_; }
-
- private:
-  GainControl* real_gain_control_;
-  int volume_;
-};
-
 struct AudioProcessingImpl::ApmPublicSubmodules {
   ApmPublicSubmodules()
       : echo_cancellation(nullptr),
         echo_control_mobile(nullptr),
         gain_control(nullptr) {}
   // Accessed externally of APM without any lock acquired.
   EchoCancellationImpl* echo_cancellation;
   EchoControlMobileImpl* echo_control_mobile;
   GainControlImpl* gain_control;
   rtc::scoped_ptr<HighPassFilterImpl> high_pass_filter;
   rtc::scoped_ptr<LevelEstimatorImpl> level_estimator;
   rtc::scoped_ptr<NoiseSuppressionImpl> noise_suppression;
   rtc::scoped_ptr<VoiceDetectionImpl> voice_detection;
-  rtc::scoped_ptr<GainControlForNewAgc> gain_control_for_new_agc;
+  rtc::scoped_ptr<GainControlForExperimentalAgc>
+      gain_control_for_experimental_agc;
 
   // Accessed internally from both render and capture.
   rtc::scoped_ptr<TransientSuppressor> transient_suppressor;
   rtc::scoped_ptr<IntelligibilityEnhancer> intelligibility_enhancer;
 };
 
 struct AudioProcessingImpl::ApmPrivateSubmodules {
   explicit ApmPrivateSubmodules(Beamformer<float>* beamformer)
       : beamformer(beamformer) {}
   // Accessed internally from capture or during initialization
@@ skipping 68 matching lines @@
     public_submodules_->gain_control =
         new GainControlImpl(this, &crit_capture_, &crit_capture_);
     public_submodules_->high_pass_filter.reset(
         new HighPassFilterImpl(&crit_capture_));
     public_submodules_->level_estimator.reset(
         new LevelEstimatorImpl(&crit_capture_));
     public_submodules_->noise_suppression.reset(
         new NoiseSuppressionImpl(&crit_capture_));
     public_submodules_->voice_detection.reset(
         new VoiceDetectionImpl(&crit_capture_));
-    public_submodules_->gain_control_for_new_agc.reset(
-        new GainControlForNewAgc(public_submodules_->gain_control));
+    public_submodules_->gain_control_for_experimental_agc.reset(
+        new GainControlForExperimentalAgc(public_submodules_->gain_control));
 
     private_submodules_->component_list.push_back(
         public_submodules_->echo_cancellation);
     private_submodules_->component_list.push_back(
         public_submodules_->echo_control_mobile);
     private_submodules_->component_list.push_back(
         public_submodules_->gain_control);
   }
 
   SetExtraOptions(config);
 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
   // Depends on gain_control_ and
-  // public_submodules_->gain_control_for_new_agc.
+  // public_submodules_->gain_control_for_experimental_agc.
   private_submodules_->agc_manager.reset();
   // Depends on gain_control_.
-  public_submodules_->gain_control_for_new_agc.reset();
+  public_submodules_->gain_control_for_experimental_agc.reset();
   while (!private_submodules_->component_list.empty()) {
     ProcessingComponent* component =
         private_submodules_->component_list.front();
     component->Destroy();
     delete component;
     private_submodules_->component_list.pop_front();
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_dump_.debug_file->Open()) {
@@ skipping 471 matching lines @@
         public_submodules_->echo_cancellation->stream_drift_samples());
     msg->set_level(gain_control()->stream_analog_level());
     msg->set_keypress(capture_.key_pressed);
   }
 #endif
 
   MaybeUpdateHistograms();
 
   AudioBuffer* ca = capture_.capture_audio.get();  // For brevity.
 
-  if (constants_.use_new_agc &&
+  if (constants_.use_experimental_agc &&
       public_submodules_->gain_control->is_enabled()) {
     private_submodules_->agc_manager->AnalyzePreProcess(
         ca->channels()[0], ca->num_channels(),
         capture_nonlocked_.fwd_proc_format.num_frames());
   }
 
   bool data_processed = is_data_processed();
   if (analysis_needed(data_processed)) {
     ca->SplitIntoFrequencyBands();
   }
@@ skipping 17 matching lines @@
 
   if (public_submodules_->echo_control_mobile->is_enabled() &&
       public_submodules_->noise_suppression->is_enabled()) {
     ca->CopyLowPassToReference();
   }
   public_submodules_->noise_suppression->ProcessCaptureAudio(ca);
   RETURN_ON_ERR(
       public_submodules_->echo_control_mobile->ProcessCaptureAudio(ca));
   public_submodules_->voice_detection->ProcessCaptureAudio(ca);
 
-  if (constants_.use_new_agc &&
+  if (constants_.use_experimental_agc &&
       public_submodules_->gain_control->is_enabled() &&
       (!capture_nonlocked_.beamformer_enabled ||
        private_submodules_->beamformer->is_target_present())) {
     private_submodules_->agc_manager->Process(
         ca->split_bands_const(0)[kBand0To8kHz], ca->num_frames_per_band(),
         capture_nonlocked_.split_rate);
   }
   RETURN_ON_ERR(public_submodules_->gain_control->ProcessCaptureAudio(ca));
 
   if (synthesis_needed(data_processed)) {
@@ skipping 181 matching lines @@
     // TODO(peah): Fix to be properly multi-threaded.
     rtc::CritScope cs(&crit_capture_);
     public_submodules_->intelligibility_enhancer->ProcessRenderAudio(
         ra->split_channels_f(kBand0To8kHz), capture_nonlocked_.split_rate,
         ra->num_channels());
   }
 
   RETURN_ON_ERR(public_submodules_->echo_cancellation->ProcessRenderAudio(ra));
   RETURN_ON_ERR(
       public_submodules_->echo_control_mobile->ProcessRenderAudio(ra));
-  if (!constants_.use_new_agc) {
+  if (!constants_.use_experimental_agc) {
     RETURN_ON_ERR(public_submodules_->gain_control->ProcessRenderAudio(ra));
   }
 
   if (formats_.rev_proc_format.sample_rate_hz() == kSampleRate32kHz &&
       is_rev_processed()) {
     ra->MergeFrequencyBands();
   }
 
   return kNoError;
 }
@@ skipping 145 matching lines @@
 
 EchoControlMobile* AudioProcessingImpl::echo_control_mobile() const {
   // Adding a lock here has no effect as it allows any access to the submodule
   // from the returned pointer.
   return public_submodules_->echo_control_mobile;
 }
 
 GainControl* AudioProcessingImpl::gain_control() const {
   // Adding a lock here has no effect as it allows any access to the submodule
   // from the returned pointer.
-  if (constants_.use_new_agc) {
-    return public_submodules_->gain_control_for_new_agc.get();
+  if (constants_.use_experimental_agc) {
+    return public_submodules_->gain_control_for_experimental_agc.get();
   }
   return public_submodules_->gain_control;
 }
 
 HighPassFilter* AudioProcessingImpl::high_pass_filter() const {
   // Adding a lock here has no effect as it allows any access to the submodule
   // from the returned pointer.
   return public_submodules_->high_pass_filter.get();
 }
 
@@ skipping 98 matching lines @@
 bool AudioProcessingImpl::render_check_rev_conversion_needed() const {
   return rev_conversion_needed();
 }
 
 bool AudioProcessingImpl::rev_conversion_needed() const {
   return (formats_.api_format.reverse_input_stream() !=
           formats_.api_format.reverse_output_stream());
 }
 
 void AudioProcessingImpl::InitializeExperimentalAgc() {
-  if (constants_.use_new_agc) {
+  if (constants_.use_experimental_agc) {
     if (!private_submodules_->agc_manager.get()) {
       private_submodules_->agc_manager.reset(new AgcManagerDirect(
           public_submodules_->gain_control,
-          public_submodules_->gain_control_for_new_agc.get(),
+          public_submodules_->gain_control_for_experimental_agc.get(),
           constants_.agc_startup_min_volume));
     }
     private_submodules_->agc_manager->Initialize();
     private_submodules_->agc_manager->SetCaptureMuted(
         capture_.output_will_be_muted);
   }
 }
 
 void AudioProcessingImpl::InitializeTransient() {
   if (capture_.transient_suppressor_enabled) {
@@ skipping 210 matching lines @@
   config.set_aecm_comfort_noise_enabled(
       public_submodules_->echo_control_mobile->is_comfort_noise_enabled());
   config.set_aecm_routing_mode(static_cast<int>(
       public_submodules_->echo_control_mobile->routing_mode()));
 
   config.set_agc_enabled(public_submodules_->gain_control->is_enabled());
   config.set_agc_mode(
       static_cast<int>(public_submodules_->gain_control->mode()));
   config.set_agc_limiter_enabled(
       public_submodules_->gain_control->is_limiter_enabled());
-  config.set_noise_robust_agc_enabled(constants_.use_new_agc);
+  config.set_noise_robust_agc_enabled(constants_.use_experimental_agc);
 
   config.set_hpf_enabled(public_submodules_->high_pass_filter->is_enabled());
 
   config.set_ns_enabled(public_submodules_->noise_suppression->is_enabled());
   config.set_ns_level(
       static_cast<int>(public_submodules_->noise_suppression->level()));
 
   config.set_transient_suppression_enabled(
       capture_.transient_suppressor_enabled);
 
   std::string serialized_config = config.SerializeAsString();
   if (!forced &&
       debug_dump_.capture.last_serialized_config == serialized_config) {
     return kNoError;
   }
 
   debug_dump_.capture.last_serialized_config = serialized_config;
 
   debug_dump_.capture.event_msg->set_type(audioproc::Event::CONFIG);
   debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                         &debug_dump_.num_bytes_left_for_log_,
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 }  // namespace webrtc