Lock scheme #4: Introduced the render sample queue for the aec and aecm

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 37 matching lines @@
       return AudioProcessing::kBadStreamParameterWarning;
     default:
       // AEC_UNSPECIFIED_ERROR
       // AEC_UNINITIALIZED_ERROR
       // AEC_NULL_POINTER_ERROR
       return AudioProcessing::kUnspecifiedError;
   }
 }
 }  // namespace
 
+const size_t EchoCancellationImpl::kAllowedValuesOfSamplesPerFrame1;
+const size_t EchoCancellationImpl::kAllowedValuesOfSamplesPerFrame2;
+
 EchoCancellationImpl::EchoCancellationImpl(const AudioProcessing* apm,
                                            CriticalSectionWrapper* crit)
     : ProcessingComponent(),
       apm_(apm),
       crit_(crit),
       drift_compensation_enabled_(false),
       metrics_enabled_(false),
       suppression_level_(kModerateSuppression),
       stream_drift_samples_(0),
       was_stream_drift_set_(false),
       stream_has_echo_(false),
       delay_logging_enabled_(false),
       extended_filter_enabled_(false),
-      delay_agnostic_enabled_(false) {
+      delay_agnostic_enabled_(false),
+      render_queue_element_max_size_(0) {
+  AllocateRenderQueue();
 }
 
 EchoCancellationImpl::~EchoCancellationImpl() {}
 
 int EchoCancellationImpl::ProcessRenderAudio(const AudioBuffer* audio) {
   if (!is_component_enabled()) {
     return apm_->kNoError;
   }
 
   assert(audio->num_frames_per_band() <= 160);
   assert(audio->num_channels() == apm_->num_reverse_channels());
 
   int err = apm_->kNoError;
 
   // The ordering convention must be followed to pass to the correct AEC.
   size_t handle_index = 0;
+  int buffer_index = 0;
   for (int i = 0; i < apm_->num_output_channels(); i++) {
     for (int j = 0; j < audio->num_channels(); j++) {
       Handle* my_handle = static_cast<Handle*>(handle(handle_index));
-      err = WebRtcAec_BufferFarend(
-          my_handle,
-          audio->split_bands_const_f(j)[kBand0To8kHz],
+      // Retrieve any error code produced by the buffering of the farend
+      // signal
+      err = WebRtcAec_GetBufferFarendError(
+          my_handle, audio->split_bands_const_f(j)[kBand0To8kHz],
           audio->num_frames_per_band());
 
       if (err != apm_->kNoError) {
         return MapError(err);  // TODO(ajm): warning possible?
       }
 
+      // Buffer the samples in the render queue.
+      RTC_DCHECK((buffer_index + audio->num_frames_per_band()) <=
+                 render_queue_element_max_size_);
+
+      memcpy(&render_queue_buffer_[buffer_index],
+             audio->split_bands_const_f(j)[kBand0To8kHz],
+             (audio->num_frames_per_band() *
+              sizeof(*audio->split_bands_const_f(j)[kBand0To8kHz])));
+
+      buffer_index += audio->num_frames_per_band();

[kwiberg-webrtc, 2015/10/27 10:43:07]

Can't you use the nurmal features of std::vector to keep track of this? In other
words, use the vector's size to keep track of how many elements there are in it,
the vectors insert function to insert elements, etc. Ask me for details if
you're unsure how.

[peah-webrtc, 2015/10/29 11:36:56]

Done.

+
       handle_index++;
     }
   }
 
+  render_queue_buffer_.resize(buffer_index);
+  render_signal_queue_->Insert(&render_queue_buffer_);

[kwiberg-webrtc, 2015/10/27 10:43:07]

Doesn't Insert return a status bool that you'd want to check?

[peah-webrtc, 2015/10/29 11:36:56]

Done.

+
   return apm_->kNoError;
 }
 
+// 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() {
+  if (!is_component_enabled()) {
+    return;
+  }
+
+  bool samples_read = render_signal_queue_->Remove(&capture_queue_buffer_);
+  while (samples_read) {

[kwiberg-webrtc, 2015/10/27 10:43:07]

Just

  while (render_signal_queue_->Remove(&capture_queue_buffer_))

? That'll replace lines 135, 136, and 153.

[peah-webrtc, 2015/10/29 11:36:56]

Done.

+    size_t handle_index = 0;
+    int buffer_index = 0;
+    const int num_frames_per_band =
+        capture_queue_buffer_.size() /
+        (apm_->num_output_channels() * apm_->num_reverse_channels());
+    for (int i = 0; i < apm_->num_output_channels(); i++) {
+      for (int j = 0; j < apm_->num_reverse_channels(); j++) {
+        Handle* my_handle = static_cast<Handle*>(handle(handle_index));
+        (void)WebRtcAec_BufferFarend(my_handle,
+                                     &capture_queue_buffer_[buffer_index],
+                                     num_frames_per_band);
+
+        buffer_index += num_frames_per_band;
+        handle_index++;
+      }
+    }
+    samples_read = render_signal_queue_->Remove(&capture_queue_buffer_);
+  }
+}
+
 int EchoCancellationImpl::ProcessCaptureAudio(AudioBuffer* audio) {
   if (!is_component_enabled()) {
     return apm_->kNoError;
   }
 
   if (!apm_->was_stream_delay_set()) {
     return apm_->kStreamParameterNotSetError;
   }
 
   if (drift_compensation_enabled_ && !was_stream_drift_set_) {
@@ skipping 209 matching lines @@
   Handle* my_handle = static_cast<Handle*>(handle(0));
   return WebRtcAec_aec_core(my_handle);
 }
 
 int EchoCancellationImpl::Initialize() {
   int err = ProcessingComponent::Initialize();
   if (err != apm_->kNoError || !is_component_enabled()) {
     return err;
   }
 
+  AllocateRenderQueue();
+
   return apm_->kNoError;
 }
 
+void EchoCancellationImpl::AllocateRenderQueue() {
+  const size_t max_frame_size = std::max(kAllowedValuesOfSamplesPerFrame1,
+                                         kAllowedValuesOfSamplesPerFrame2);
+  const size_t min_frame_size = std::min(kAllowedValuesOfSamplesPerFrame1,
+                                         kAllowedValuesOfSamplesPerFrame2);
+
+  render_queue_element_max_size_ =
+      (max_frame_size * num_handles_required());

[kwiberg-webrtc, 2015/10/27 10:43:07]

Unnecessary parentheses.

[peah-webrtc, 2015/10/29 11:36:56]

Done.

+
+  const size_t render_queue_element_min_size =
+      (min_frame_size * num_handles_required());

[kwiberg-webrtc, 2015/10/27 10:43:07]

Unnecessary parentheses.

[peah-webrtc, 2015/10/29 11:36:56]

Done.

+
+  std::vector<float> template_queue_element(render_queue_element_max_size_);
+
+  render_signal_queue_.reset(
+      new SwapQueue<std::vector<float>, AecRenderQueueItemVerifier>(
+          kMaxNumFramesToBuffer,
+          AecRenderQueueItemVerifier(render_queue_element_min_size,
+                                     render_queue_element_max_size_),
+          template_queue_element));
+
+  render_queue_buffer_.resize(render_queue_element_max_size_);
+  capture_queue_buffer_.resize(render_queue_element_max_size_);
+}
+
 void EchoCancellationImpl::SetExtraOptions(const Config& config) {
   extended_filter_enabled_ = config.Get<ExtendedFilter>().enabled;
   delay_agnostic_enabled_ = config.Get<DelayAgnostic>().enabled;
   Configure();
 }
 
 void* EchoCancellationImpl::CreateHandle() const {
   return WebRtcAec_Create();
 }
 
@@ skipping 12 matching lines @@
                        48000);
 }
 
 int EchoCancellationImpl::ConfigureHandle(void* handle) const {
   assert(handle != NULL);
   AecConfig config;
   config.metricsMode = metrics_enabled_;
   config.nlpMode = MapSetting(suppression_level_);
   config.skewMode = drift_compensation_enabled_;
   config.delay_logging = delay_logging_enabled_;
-
   WebRtcAec_enable_extended_filter(
       WebRtcAec_aec_core(static_cast<Handle*>(handle)),
       extended_filter_enabled_ ? 1 : 0);
   WebRtcAec_enable_delay_agnostic(
       WebRtcAec_aec_core(static_cast<Handle*>(handle)),
       delay_agnostic_enabled_ ? 1 : 0);
   return WebRtcAec_set_config(static_cast<Handle*>(handle), config);
 }
 
 int EchoCancellationImpl::num_handles_required() const {
   return apm_->num_output_channels() *
          apm_->num_reverse_channels();
 }
 
 int EchoCancellationImpl::GetHandleError(void* handle) const {
   assert(handle != NULL);
   return AudioProcessing::kUnspecifiedError;
 }
+
 }  // namespace webrtc