Removed the dependency on AudioProcessingImpl in GainControlImpl

webrtc/modules/audio_processing/gain_control_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 72 matching lines @@
 
  private:
   Handle* state_;
   // TODO(peah): Remove the optional once the initialization is moved into the
   // ctor.
   rtc::Optional<int> capture_level_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(GainController);
 };
 
-GainControlImpl::GainControlImpl(const AudioProcessing* apm,
-                                 rtc::CriticalSection* crit_render,
+GainControlImpl::GainControlImpl(rtc::CriticalSection* crit_render,
                                  rtc::CriticalSection* crit_capture)
-    : apm_(apm),
-      crit_render_(crit_render),
+    : crit_render_(crit_render),
       crit_capture_(crit_capture),
       mode_(kAdaptiveAnalog),
       minimum_capture_level_(0),
       maximum_capture_level_(255),
       limiter_enabled_(true),
       target_level_dbfs_(3),
       compression_gain_db_(9),
       analog_capture_level_(0),
       was_analog_level_set_(false),
       stream_is_saturated_(false),
       render_queue_element_max_size_(0) {
-  RTC_DCHECK(apm);
   RTC_DCHECK(crit_render);
   RTC_DCHECK(crit_capture);
 }
 
 GainControlImpl::~GainControlImpl() {}
 
 int GainControlImpl::ProcessRenderAudio(AudioBuffer* audio) {
   rtc::CritScope cs(crit_render_);
   if (!enabled_) {
     return AudioProcessing::kNoError;
@@ skipping 32 matching lines @@
 // a queue. All the data chunks are buffered into the farend signal of the AGC.
 void GainControlImpl::ReadQueuedRenderData() {
   rtc::CritScope cs(crit_capture_);
 
   if (!enabled_) {
     return;
   }
 
   while (render_signal_queue_->Remove(&capture_queue_buffer_)) {
     size_t buffer_index = 0;
+    RTC_DCHECK(num_proc_channels_);
+    RTC_DCHECK_LT(0ul, *num_proc_channels_);
     const size_t num_frames_per_band =
-        capture_queue_buffer_.size() / num_handles_required();
+        capture_queue_buffer_.size() / (*num_proc_channels_);
     for (auto& gain_controller : gain_controllers_) {
       WebRtcAgc_AddFarend(gain_controller->state(),
                           &capture_queue_buffer_[buffer_index],
                           num_frames_per_band);
 
       buffer_index += num_frames_per_band;
     }
   }
 }
 
 int GainControlImpl::AnalyzeCaptureAudio(AudioBuffer* audio) {
   rtc::CritScope cs(crit_capture_);
 
   if (!enabled_) {
     return AudioProcessing::kNoError;
   }
 
+  RTC_DCHECK(num_proc_channels_);
   RTC_DCHECK_GE(160u, audio->num_frames_per_band());
-  RTC_DCHECK_EQ(audio->num_channels(), num_handles_required());
-  RTC_DCHECK_LE(num_handles_required(), gain_controllers_.size());
+  RTC_DCHECK_EQ(audio->num_channels(), *num_proc_channels_);
+  RTC_DCHECK_LE(*num_proc_channels_, gain_controllers_.size());
 
   if (mode_ == kAdaptiveAnalog) {
     int capture_channel = 0;
     for (auto& gain_controller : gain_controllers_) {
       gain_controller->set_capture_level(analog_capture_level_);
       int err = WebRtcAgc_AddMic(
           gain_controller->state(), audio->split_bands(capture_channel),
           audio->num_bands(), audio->num_frames_per_band());
 
       if (err != AudioProcessing::kNoError) {
@@ skipping 15 matching lines @@
       if (err != AudioProcessing::kNoError) {
         return AudioProcessing::kUnspecifiedError;
       }
       ++capture_channel;
     }
   }
 
   return AudioProcessing::kNoError;
 }
 
-int GainControlImpl::ProcessCaptureAudio(AudioBuffer* audio) {
+int GainControlImpl::ProcessCaptureAudio(AudioBuffer* audio,
+                                         bool stream_has_echo) {
   rtc::CritScope cs(crit_capture_);
 
   if (!enabled_) {
     return AudioProcessing::kNoError;
   }
 
   if (mode_ == kAdaptiveAnalog && !was_analog_level_set_) {
     return AudioProcessing::kStreamParameterNotSetError;
   }
 
+  RTC_DCHECK(num_proc_channels_);
   RTC_DCHECK_GE(160u, audio->num_frames_per_band());
-  RTC_DCHECK_EQ(audio->num_channels(), num_handles_required());
+  RTC_DCHECK_EQ(audio->num_channels(), *num_proc_channels_);
 
   stream_is_saturated_ = false;
   int capture_channel = 0;
   for (auto& gain_controller : gain_controllers_) {
     int32_t capture_level_out = 0;
     uint8_t saturation_warning = 0;
 
     // The call to stream_has_echo() is ok from a deadlock perspective
     // as the capture lock is allready held.
     int err = WebRtcAgc_Process(
         gain_controller->state(), audio->split_bands_const(capture_channel),
         audio->num_bands(), audio->num_frames_per_band(),
         audio->split_bands(capture_channel),
         gain_controller->get_capture_level(), &capture_level_out,
-        apm_->echo_cancellation()->stream_has_echo(), &saturation_warning);
+        stream_has_echo, &saturation_warning);
 
     if (err != AudioProcessing::kNoError) {
       return AudioProcessing::kUnspecifiedError;
     }
 
     gain_controller->set_capture_level(capture_level_out);
     if (saturation_warning == 1) {
       stream_is_saturated_ = true;
     }
 
     ++capture_channel;
   }
 
+  RTC_DCHECK_LT(0ul, *num_proc_channels_);
   if (mode_ == kAdaptiveAnalog) {
     // Take the analog level to be the average across the handles.
     analog_capture_level_ = 0;
     for (auto& gain_controller : gain_controllers_) {
       analog_capture_level_ += gain_controller->get_capture_level();
     }
 
-    analog_capture_level_ /= num_handles_required();
+    analog_capture_level_ /= (*num_proc_channels_);
   }
 
   was_analog_level_set_ = false;
   return AudioProcessing::kNoError;
 }
 
 // TODO(ajm): ensure this is called under kAdaptiveAnalog.
 int GainControlImpl::set_stream_analog_level(int level) {
   rtc::CritScope cs(crit_capture_);
 
@@ skipping 12 matching lines @@
   //assert(mode_ == kAdaptiveAnalog);
 
   return analog_capture_level_;
 }
 
 int GainControlImpl::Enable(bool enable) {
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
   if (enable && !enabled_) {
     enabled_ = enable;  // Must be set before Initialize() is called.
-    Initialize();
+
+    RTC_DCHECK(num_proc_channels_);
+    RTC_DCHECK(sample_rate_hz_);
+    Initialize(*num_proc_channels_, *sample_rate_hz_);
   } else {
     enabled_ = enable;
   }
   return AudioProcessing::kNoError;
 }
 
 bool GainControlImpl::is_enabled() const {
   rtc::CritScope cs(crit_capture_);
   return enabled_;
 }
 
 int GainControlImpl::set_mode(Mode mode) {
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
   if (MapSetting(mode) == -1) {
     return AudioProcessing::kBadParameterError;
   }
 
   mode_ = mode;
-  Initialize();
+  RTC_DCHECK(num_proc_channels_);
+  RTC_DCHECK(sample_rate_hz_);
+  Initialize(*num_proc_channels_, *sample_rate_hz_);
   return AudioProcessing::kNoError;
 }
 
 GainControl::Mode GainControlImpl::mode() const {
   rtc::CritScope cs(crit_capture_);
   return mode_;
 }
 
 int GainControlImpl::set_analog_level_limits(int minimum,
                                              int maximum) {
   rtc::CritScope cs(crit_capture_);
   if (minimum < 0) {
     return AudioProcessing::kBadParameterError;
   }
 
   if (maximum > 65535) {
     return AudioProcessing::kBadParameterError;
   }
 
   if (maximum < minimum) {
     return AudioProcessing::kBadParameterError;
   }
 
   minimum_capture_level_ = minimum;
   maximum_capture_level_ = maximum;
 
-  Initialize();
+  RTC_DCHECK(num_proc_channels_);
+  RTC_DCHECK(sample_rate_hz_);
+  Initialize(*num_proc_channels_, *sample_rate_hz_);
   return AudioProcessing::kNoError;
 }
 
 int GainControlImpl::analog_level_minimum() const {
   rtc::CritScope cs(crit_capture_);
   return minimum_capture_level_;
 }
 
 int GainControlImpl::analog_level_maximum() const {
   rtc::CritScope cs(crit_capture_);
@@ skipping 43 matching lines @@
     limiter_enabled_ = enable;
   }
   return Configure();
 }
 
 bool GainControlImpl::is_limiter_enabled() const {
   rtc::CritScope cs(crit_capture_);
   return limiter_enabled_;
 }
 
-void GainControlImpl::Initialize() {
+void GainControlImpl::Initialize(size_t num_proc_channels, int sample_rate_hz) {
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
+
+  num_proc_channels_ = rtc::Optional<size_t>(num_proc_channels);
+  sample_rate_hz_ = rtc::Optional<int>(sample_rate_hz);
+
   if (!enabled_) {
     return;
   }
 
-  int sample_rate_hz = apm_->proc_sample_rate_hz();
-  gain_controllers_.resize(num_handles_required());
+  gain_controllers_.resize(*num_proc_channels_);
   for (auto& gain_controller : gain_controllers_) {
     if (!gain_controller) {
       gain_controller.reset(new GainController());
     }
     gain_controller->Initialize(minimum_capture_level_, maximum_capture_level_,
-                                mode_, sample_rate_hz, analog_capture_level_);
+                                mode_, *sample_rate_hz_, analog_capture_level_);
   }
 
   Configure();
 
   AllocateRenderQueue();
 }
 
 void GainControlImpl::AllocateRenderQueue() {
+  rtc::CritScope cs_render(crit_render_);
+  rtc::CritScope cs_capture(crit_capture_);
+
+  RTC_DCHECK(num_proc_channels_);
   const size_t new_render_queue_element_max_size = std::max<size_t>(
       static_cast<size_t>(1),
-      kMaxAllowedValuesOfSamplesPerFrame * num_handles_required());
-
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
+      kMaxAllowedValuesOfSamplesPerFrame * (*num_proc_channels_));
 
   if (render_queue_element_max_size_ < new_render_queue_element_max_size) {
     render_queue_element_max_size_ = new_render_queue_element_max_size;
     std::vector<int16_t> template_queue_element(render_queue_element_max_size_);
 
     render_signal_queue_.reset(
         new SwapQueue<std::vector<int16_t>, RenderQueueItemVerifier<int16_t>>(
             kMaxNumFramesToBuffer, template_queue_element,
             RenderQueueItemVerifier<int16_t>(render_queue_element_max_size_)));
 
@@ skipping 20 matching lines @@
   int error = AudioProcessing::kNoError;
   for (auto& gain_controller : gain_controllers_) {
     const int handle_error =
         WebRtcAgc_set_config(gain_controller->state(), config);
     if (handle_error != AudioProcessing::kNoError) {
       error = handle_error;
     }
   }
   return error;
 }
-
-size_t GainControlImpl::num_handles_required() const {
-  // Not locked as it only relies on APM public API which is threadsafe.
-  return apm_->num_proc_channels();
-}
 }  // namespace webrtc