Adding second layer of the echo canceller 3 functionality.

webrtc/modules/audio_processing/aec3/echo_canceller3.cc

 /*
  *  Copyright (c) 2016 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.
  */
 #include "webrtc/modules/audio_processing/aec3/echo_canceller3.h"
@@ skipping 35 matching lines @@
   RTC_DCHECK_GE(1, sub_frame_index);
   RTC_DCHECK_EQ(frame->size(), sub_frame_view->size());
   for (size_t k = 0; k < frame->size(); ++k) {
     (*sub_frame_view)[k] = rtc::ArrayView<float>(
         &(*frame)[k][sub_frame_index * kSubFrameLength], kSubFrameLength);
   }
 }
 
 void ProcessCaptureFrameContent(
     AudioBuffer* capture,
-    bool known_echo_path_change,
+    bool level_change,
     bool saturated_microphone_signal,
     size_t sub_frame_index,
     FrameBlocker* capture_blocker,
     BlockFramer* output_framer,
     BlockProcessor* block_processor,
     std::vector<std::vector<float>>* block,
     std::vector<rtc::ArrayView<float>>* sub_frame_view) {
   FillSubFrameView(capture, sub_frame_index, sub_frame_view);
   capture_blocker->InsertSubFrameAndExtractBlock(*sub_frame_view, block);
-  block_processor->ProcessCapture(known_echo_path_change,
-                                  saturated_microphone_signal, block);
+  block_processor->ProcessCapture(level_change, saturated_microphone_signal,
+                                  block);
   output_framer->InsertBlockAndExtractSubFrame(*block, sub_frame_view);
 }
 
 void ProcessRemainingCaptureFrameContent(
-    bool known_echo_path_change,
+    bool level_change,
     bool saturated_microphone_signal,
     FrameBlocker* capture_blocker,
     BlockFramer* output_framer,
     BlockProcessor* block_processor,
     std::vector<std::vector<float>>* block) {
   if (!capture_blocker->IsBlockAvailable()) {
     return;
   }
 
   capture_blocker->ExtractBlock(block);
-  block_processor->ProcessCapture(known_echo_path_change,
-                                  saturated_microphone_signal, block);
+  block_processor->ProcessCapture(level_change, saturated_microphone_signal,
+                                  block);
   output_framer->InsertBlock(*block);
 }
 
 bool BufferRenderFrameContent(
     std::vector<std::vector<float>>* render_frame,
     size_t sub_frame_index,
     FrameBlocker* render_blocker,
     BlockProcessor* block_processor,
     std::vector<std::vector<float>>* block,
     std::vector<rtc::ArrayView<float>>* sub_frame_view) {
   FillSubFrameView(render_frame, sub_frame_index, sub_frame_view);
   render_blocker->InsertSubFrameAndExtractBlock(*sub_frame_view, block);
   return block_processor->BufferRender(block);
 }
 
 bool BufferRemainingRenderFrameContent(FrameBlocker* render_blocker,
                                        BlockProcessor* block_processor,
                                        std::vector<std::vector<float>>* block) {
   if (!render_blocker->IsBlockAvailable()) {
-    return false;
+    return true;
   }
   render_blocker->ExtractBlock(block);
   return block_processor->BufferRender(block);
 }
 
 void CopyAudioBufferIntoFrame(AudioBuffer* buffer,
                               size_t num_bands,
                               size_t frame_length,
                               std::vector<std::vector<float>>* frame) {
   RTC_DCHECK_EQ(num_bands, frame->size());
@@ skipping 153 matching lines @@
   for (size_t k = 0; k < capture->num_channels(); ++k) {
     saturated_microphone_signal_ |=
         DetectSaturation(rtc::ArrayView<const float>(capture->channels_f()[k],
                                                      capture->num_frames()));
     if (saturated_microphone_signal_) {
       break;
     }
   }
 }
 
-void EchoCanceller3::ProcessCapture(AudioBuffer* capture,
-                                    bool known_echo_path_change) {
+void EchoCanceller3::ProcessCapture(AudioBuffer* capture, bool level_change) {
   RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
   RTC_DCHECK(capture);
   RTC_DCHECK_EQ(1u, capture->num_channels());
   RTC_DCHECK_EQ(num_bands_, capture->num_bands());
   RTC_DCHECK_EQ(frame_length_, capture->num_frames_per_band());
 
   rtc::ArrayView<float> capture_lower_band =
       rtc::ArrayView<float>(&capture->split_bands_f(0)[0][0], frame_length_);
 
   data_dumper_->DumpWav("aec3_capture_input", capture_lower_band,
                         LowestBandRate(sample_rate_hz_), 1);
 
-  const bool render_buffer_overrun = EmptyRenderQueue();
-  RTC_DCHECK(!render_buffer_overrun);
+  const bool successful_buffering = EmptyRenderQueue();
+  RTC_DCHECK(successful_buffering);
 
   if (capture_highpass_filter_) {
     capture_highpass_filter_->Process(capture_lower_band);
   }
 
-  ProcessCaptureFrameContent(capture, known_echo_path_change,
-                             saturated_microphone_signal_, 0, &capture_blocker_,
-                             &output_framer_, block_processor_.get(), &block_,
-                             &sub_frame_view_);
+  ProcessCaptureFrameContent(
+      capture, level_change, saturated_microphone_signal_, 0, &capture_blocker_,
+      &output_framer_, block_processor_.get(), &block_, &sub_frame_view_);
 
   if (sample_rate_hz_ != 8000) {
     ProcessCaptureFrameContent(
-        capture, known_echo_path_change, saturated_microphone_signal_, 1,
+        capture, level_change, saturated_microphone_signal_, 1,
         &capture_blocker_, &output_framer_, block_processor_.get(), &block_,
         &sub_frame_view_);
   }
 
   ProcessRemainingCaptureFrameContent(
-      known_echo_path_change, saturated_microphone_signal_, &capture_blocker_,
+      level_change, saturated_microphone_signal_, &capture_blocker_,
       &output_framer_, block_processor_.get(), &block_);
 
   data_dumper_->DumpWav("aec3_capture_output", frame_length_,
                         &capture->split_bands_f(0)[0][0],
                         LowestBandRate(sample_rate_hz_), 1);
 }
 
 std::string EchoCanceller3::ToString(
     const AudioProcessing::Config::EchoCanceller3& config) {
   std::stringstream ss;
   ss << "{"
      << "enabled: " << (config.enabled ? "true" : "false") << "}";
   return ss.str();
 }
 
 bool EchoCanceller3::Validate(
     const AudioProcessing::Config::EchoCanceller3& config) {
   return true;
 }
 
 bool EchoCanceller3::EmptyRenderQueue() {
   RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
-  bool render_buffer_overrun = false;
+  bool successful_buffering = true;
   bool frame_to_buffer =
       render_transfer_queue_.Remove(&render_queue_output_frame_);
   while (frame_to_buffer) {
-    render_buffer_overrun |= BufferRenderFrameContent(
-        &render_queue_output_frame_, 0, &render_blocker_,
-        block_processor_.get(), &block_, &sub_frame_view_);
+    successful_buffering =
+        BufferRenderFrameContent(&render_queue_output_frame_, 0,
+                                 &render_blocker_, block_processor_.get(),
+                                 &block_, &sub_frame_view_) &&
+        successful_buffering;
 
     if (sample_rate_hz_ != 8000) {
-      render_buffer_overrun |= BufferRenderFrameContent(
-          &render_queue_output_frame_, 1, &render_blocker_,
-          block_processor_.get(), &block_, &sub_frame_view_);
+      successful_buffering =
+          BufferRenderFrameContent(&render_queue_output_frame_, 1,
+                                   &render_blocker_, block_processor_.get(),
+                                   &block_, &sub_frame_view_) &&
+          successful_buffering;
     }
 
-    render_buffer_overrun |= BufferRemainingRenderFrameContent(
-        &render_blocker_, block_processor_.get(), &block_);
+    successful_buffering =
+        BufferRemainingRenderFrameContent(&render_blocker_,
+                                          block_processor_.get(), &block_) &&
+        successful_buffering;
 
     frame_to_buffer =
         render_transfer_queue_.Remove(&render_queue_output_frame_);
   }
-  return render_buffer_overrun;
+  return successful_buffering;
 }
 
 }  // namespace webrtc