Removed the AudioProcessing dependency in EchoCancellerImpl

webrtc/modules/audio_processing/echo_cancellation_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 39 matching lines @@
 }
 
 // Maximum length that a frame of samples can have.
 static const size_t kMaxAllowedValuesOfSamplesPerFrame = 160;
 // Maximum number of frames to buffer in the render queue.
 // TODO(peah): Decrease this once we properly handle hugely unbalanced
 // reverse and forward call numbers.
 static const size_t kMaxNumFramesToBuffer = 100;
 }  // namespace
 
+struct EchoCancellationImpl::StreamProperties {
+ public:
+  StreamProperties(int sample_rate_hz,
+                   size_t num_reverse_channels,
+                   size_t num_output_channels,
+                   size_t num_proc_channels)
+      : sample_rate_hz(sample_rate_hz),
+        num_reverse_channels(num_reverse_channels),
+        num_output_channels(num_output_channels),
+        num_proc_channels(num_proc_channels) {}
+
+  int sample_rate_hz;
+  size_t num_reverse_channels;
+  size_t num_output_channels;
+  size_t num_proc_channels;
+};
+
 class EchoCancellationImpl::Canceller {
  public:
   Canceller() {
     state_ = WebRtcAec_Create();
     RTC_DCHECK(state_);
   }
 
   ~Canceller() {
     RTC_CHECK(state_);
     WebRtcAec_Free(state_);
@@ skipping 36 matching lines @@
 }
 
 EchoCancellationImpl::~EchoCancellationImpl() {}
 
 int EchoCancellationImpl::ProcessRenderAudio(const AudioBuffer* audio) {
   rtc::CritScope cs_render(crit_render_);
   if (!enabled_) {
     return AudioProcessing::kNoError;
   }
 
+  RTC_DCHECK(!!stream_properties_);
   RTC_DCHECK_GE(160u, audio->num_frames_per_band());
-  RTC_DCHECK_EQ(audio->num_channels(), apm_->num_reverse_channels());
-  RTC_DCHECK_GE(cancellers_.size(),
-                apm_->num_output_channels() * audio->num_channels());
+  RTC_DCHECK_EQ(audio->num_channels(),
+                stream_properties_->num_reverse_channels);
+  RTC_DCHECK_GE(cancellers_.size(), stream_properties_->num_output_channels *
+                                        audio->num_channels());
 
   int err = AudioProcessing::kNoError;
 
   // The ordering convention must be followed to pass to the correct AEC.
   size_t handle_index = 0;
   render_queue_buffer_.clear();
-  for (size_t i = 0; i < apm_->num_output_channels(); i++) {
+  for (size_t i = 0; i < stream_properties_->num_output_channels; i++) {
     for (size_t j = 0; j < audio->num_channels(); j++) {
       // Retrieve any error code produced by the buffering of the farend
       // signal.
       err = WebRtcAec_GetBufferFarendError(
           cancellers_[handle_index++]->state(),
           audio->split_bands_const_f(j)[kBand0To8kHz],
           audio->num_frames_per_band());
 
       if (err != AudioProcessing::kNoError) {
         return MapError(err);  // TODO(ajm): warning possible?
@@ skipping 20 matching lines @@
 }
 
 // Read chunks of data that were received and queued on the render side from
 // a queue. All the data chunks are buffered into the farend signal of the AEC.
 void EchoCancellationImpl::ReadQueuedRenderData() {
   rtc::CritScope cs_capture(crit_capture_);
   if (!enabled_) {
     return;
   }
 
+  RTC_DCHECK(!!stream_properties_);
   while (render_signal_queue_->Remove(&capture_queue_buffer_)) {
     size_t handle_index = 0;
     size_t buffer_index = 0;
     const size_t num_frames_per_band =
         capture_queue_buffer_.size() /
-        (apm_->num_output_channels() * apm_->num_reverse_channels());
-    for (size_t i = 0; i < apm_->num_output_channels(); i++) {
-      for (size_t j = 0; j < apm_->num_reverse_channels(); j++) {
+        (stream_properties_->num_output_channels *
+         stream_properties_->num_reverse_channels);
+    for (size_t i = 0; i < stream_properties_->num_output_channels; i++) {
+      for (size_t j = 0; j < stream_properties_->num_reverse_channels; j++) {
         WebRtcAec_BufferFarend(cancellers_[handle_index++]->state(),
                                &capture_queue_buffer_[buffer_index],
                                num_frames_per_band);
 
         buffer_index += num_frames_per_band;
       }
     }
   }
 }
 
-int EchoCancellationImpl::ProcessCaptureAudio(AudioBuffer* audio) {
+int EchoCancellationImpl::ProcessCaptureAudio(AudioBuffer* audio,
+                                              int stream_delay_ms) {
   rtc::CritScope cs_capture(crit_capture_);
   if (!enabled_) {
     return AudioProcessing::kNoError;
   }
 
-  if (!apm_->was_stream_delay_set()) {
-    return AudioProcessing::kStreamParameterNotSetError;
-  }
-
   if (drift_compensation_enabled_ && !was_stream_drift_set_) {
     return AudioProcessing::kStreamParameterNotSetError;
   }
 
+  RTC_DCHECK(!!stream_properties_);
   RTC_DCHECK_GE(160u, audio->num_frames_per_band());
-  RTC_DCHECK_EQ(audio->num_channels(), apm_->num_proc_channels());
+  RTC_DCHECK_EQ(audio->num_channels(), stream_properties_->num_proc_channels);
 
   int err = AudioProcessing::kNoError;
 
   // The ordering convention must be followed to pass to the correct AEC.
   size_t handle_index = 0;
   stream_has_echo_ = false;
   for (size_t i = 0; i < audio->num_channels(); i++) {
-    for (size_t j = 0; j < apm_->num_reverse_channels(); j++) {
-      err = WebRtcAec_Process(cancellers_[handle_index]->state(),
-                              audio->split_bands_const_f(i), audio->num_bands(),
-                              audio->split_bands_f(i),
-                              audio->num_frames_per_band(),
-                              apm_->stream_delay_ms(), stream_drift_samples_);
+    for (size_t j = 0; j < stream_properties_->num_reverse_channels; j++) {
+      err = WebRtcAec_Process(
+          cancellers_[handle_index]->state(), audio->split_bands_const_f(i),
+          audio->num_bands(), audio->split_bands_f(i),
+          audio->num_frames_per_band(), stream_delay_ms, stream_drift_samples_);
 
       if (err != AudioProcessing::kNoError) {
         err = MapError(err);
         // TODO(ajm): Figure out how to return warnings properly.
         if (err != AudioProcessing::kBadStreamParameterWarning) {
           return err;
         }
       }
 
       int status = 0;
@@ skipping 12 matching lines @@
   }
 
   was_stream_drift_set_ = false;
   return AudioProcessing::kNoError;
 }
 
 int EchoCancellationImpl::Enable(bool enable) {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
-  // Ensure AEC and AECM are not both enabled.
-  // The is_enabled call is safe from a deadlock perspective
-  // as both locks are already held in the correct order.
-  if (enable && apm_->echo_control_mobile()->is_enabled()) {

[peah-webrtc, 2016/03/07 13:12:40]

Please examine this change carefully as it is actually an api-breaking change.
The check is moved from this function call to the ProcessStream() call in APM,
which will then report an error message if both AEC and AECM are active at the
same time.

I saw this approach as the only way to remove the dependency of APM without
first deprecating the AEC Enable call, which is a public API call in APM.

Please let me know your concerns about this and whether you see any better
solution for this!

-    return AudioProcessing::kBadParameterError;
-  }
 
   if (enable && !enabled_) {
     enabled_ = enable;  // Must be set before Initialize() is called.
-    Initialize();
+
+    // TODO(peah): Simplify once the Enable function has been removed from
+    // the public APM API.
+    RTC_DCHECK(!!stream_properties_);
+    Initialize(stream_properties_->sample_rate_hz,
+               stream_properties_->num_reverse_channels,
+               stream_properties_->num_output_channels,
+               stream_properties_->num_proc_channels);
   } else {
     enabled_ = enable;
   }
   return AudioProcessing::kNoError;
 }
 
 bool EchoCancellationImpl::is_enabled() const {
   rtc::CritScope cs(crit_capture_);
   return enabled_;
 }
@@ skipping 160 matching lines @@
 }
 
 struct AecCore* EchoCancellationImpl::aec_core() const {
   rtc::CritScope cs(crit_capture_);
   if (!enabled_) {
     return NULL;
   }
   return WebRtcAec_aec_core(cancellers_[0]->state());
 }
 
-void EchoCancellationImpl::Initialize() {
+void EchoCancellationImpl::Initialize(int sample_rate_hz,
+                                      size_t num_reverse_channels,
+                                      size_t num_output_channels,
+                                      size_t num_proc_channels) {
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
+
+  stream_properties_.reset(
+      new StreamProperties(sample_rate_hz, num_reverse_channels,
+                           num_output_channels, num_proc_channels));
+
   if (!enabled_) {
     return;
   }
 
-  if (num_handles_required() > cancellers_.size()) {
+  if (NumCancellersRequired() > cancellers_.size()) {
     const size_t cancellers_old_size = cancellers_.size();
-    cancellers_.resize(num_handles_required());
+    cancellers_.resize(NumCancellersRequired());
 
     for (size_t i = cancellers_old_size; i < cancellers_.size(); ++i) {
       cancellers_[i].reset(new Canceller());
     }
   }
 
-  const int sample_rate_hz = apm_->proc_sample_rate_hz();
   for (auto& canceller : cancellers_) {
     canceller->Initialize(sample_rate_hz);
   }
 
   Configure();
 
   AllocateRenderQueue();
 }
 
 int EchoCancellationImpl::GetSystemDelayInSamples() const {
   rtc::CritScope cs(crit_capture_);
   RTC_DCHECK(enabled_);
   // Report the delay for the first AEC component.
   return WebRtcAec_system_delay(
       WebRtcAec_aec_core(cancellers_[0]->state()));
 }
 
 void EchoCancellationImpl::AllocateRenderQueue() {
   const size_t new_render_queue_element_max_size = std::max<size_t>(
       static_cast<size_t>(1),
-      kMaxAllowedValuesOfSamplesPerFrame * num_handles_required());
+      kMaxAllowedValuesOfSamplesPerFrame * NumCancellersRequired());
 
   rtc::CritScope cs_render(crit_render_);
   rtc::CritScope cs_capture(crit_capture_);
 
   // Reallocate the queue if the queue item size is too small to fit the
   // data to put in the queue.
   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<float> template_queue_element(render_queue_element_max_size_);
@@ skipping 38 matching lines @@
     WebRtcAec_enable_next_generation_aec(WebRtcAec_aec_core(canceller->state()),
                                          next_generation_aec_enabled_ ? 1 : 0);
     const int handle_error = WebRtcAec_set_config(canceller->state(), config);
     if (handle_error != AudioProcessing::kNoError) {
       error = AudioProcessing::kNoError;
     }
   }
   return error;
 }
 
-size_t EchoCancellationImpl::num_handles_required() const {
-  // Not locked as it only relies on APM public API which is threadsafe.
-  return apm_->num_output_channels() * apm_->num_reverse_channels();
+size_t EchoCancellationImpl::NumCancellersRequired() const {
+  RTC_DCHECK(!!stream_properties_);
+  return stream_properties_->num_output_channels *
+         stream_properties_->num_reverse_channels;
 }
 
 }  // namespace webrtc