Adding second layer of the echo canceller 3 functionality.

webrtc/modules/audio_processing/aec3/echo_canceller3_unittest.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.
  */
 
@@ skipping 10 matching lines @@
 #include "webrtc/modules/audio_processing/aec3/block_processor.h"
 #include "webrtc/modules/audio_processing/aec3/frame_blocker.h"
 #include "webrtc/modules/audio_processing/aec3/mock/mock_block_processor.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 
+using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 // Populates the frame with linearly increasing sample values for each band,
 // with a band-specific offset, in order to allow simple bitexactness
 // verification for each band.
 void PopulateInputFrame(size_t frame_length,
                         size_t num_bands,
                         size_t frame_index,
                         float* const* frame,
@@ skipping 34 matching lines @@
 }
 
 // Class for testing that the capture data is properly received by the block
 // processor and that the processor data is properly passed to the
 // EchoCanceller3 output.
 class CaptureTransportVerificationProcessor : public BlockProcessor {
  public:
   explicit CaptureTransportVerificationProcessor(size_t num_bands) {}
   ~CaptureTransportVerificationProcessor() override = default;
 
-  void ProcessCapture(bool known_echo_path_change,
+  void ProcessCapture(bool level_change,
                       bool saturated_microphone_signal,
                       std::vector<std::vector<float>>* capture_block) override {
   }
 
   bool BufferRender(std::vector<std::vector<float>>* block) override {
-    return false;
+    return true;
   }
 
-  void ReportEchoLeakage(bool leakage_detected) override {}
+  void UpdateEchoLeakageStatus(bool leakage_detected) override {}
 
  private:
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTransportVerificationProcessor);
 };
 
 // Class for testing that the render data is properly received by the block
 // processor.
 class RenderTransportVerificationProcessor : public BlockProcessor {
  public:
   explicit RenderTransportVerificationProcessor(size_t num_bands) {}
   ~RenderTransportVerificationProcessor() override = default;
 
-  void ProcessCapture(bool known_echo_path_change,
+  void ProcessCapture(bool level_change,
                       bool saturated_microphone_signal,
                       std::vector<std::vector<float>>* capture_block) override {
     std::vector<std::vector<float>> render_block =
         received_render_blocks_.front();
     received_render_blocks_.pop_front();
     capture_block->swap(render_block);
   }
 
   bool BufferRender(std::vector<std::vector<float>>* block) override {
     received_render_blocks_.push_back(*block);
-    return false;
+    return true;
   }
 
-  void ReportEchoLeakage(bool leakage_detected) override {}
+  void UpdateEchoLeakageStatus(bool leakage_detected) override {}
 
  private:
   std::deque<std::vector<std::vector<float>>> received_render_blocks_;
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RenderTransportVerificationProcessor);
 };
 
 class EchoCanceller3Tester {
  public:
   explicit EchoCanceller3Tester(int sample_rate_hz)
       : sample_rate_hz_(sample_rate_hz),
@@ skipping 78 matching lines @@
     const size_t num_full_blocks_per_frame =
         rtc::CheckedDivExact(LowestBandRate(sample_rate_hz_), 100) / kBlockSize;
     const size_t expected_num_block_to_process =
         (kNumFramesToProcess *
          rtc::CheckedDivExact(LowestBandRate(sample_rate_hz_), 100)) /
         kBlockSize;
     std::unique_ptr<testing::StrictMock<webrtc::test::MockBlockProcessor>>
         block_processor_mock(
             new StrictMock<webrtc::test::MockBlockProcessor>());
     EXPECT_CALL(*block_processor_mock, BufferRender(_))
-        .Times(expected_num_block_to_process);
-    EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(_)).Times(0);
+        .Times(expected_num_block_to_process)
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(_)).Times(0);
 
     switch (echo_path_change_test_variant) {
       case EchoPathChangeTestVariant::kNone:
         EXPECT_CALL(*block_processor_mock, ProcessCapture(false, _, _))
             .Times(expected_num_block_to_process);
         break;
       case EchoPathChangeTestVariant::kOneSticky:
         EXPECT_CALL(*block_processor_mock, ProcessCapture(true, _, _))
             .Times(expected_num_block_to_process);
         break;
@@ skipping 55 matching lines @@
   void RunEchoLeakageVerificationTest(
       EchoLeakageTestVariant leakage_report_variant) {
     const size_t expected_num_block_to_process =
         (kNumFramesToProcess *
          rtc::CheckedDivExact(LowestBandRate(sample_rate_hz_), 100)) /
         kBlockSize;
     std::unique_ptr<testing::StrictMock<webrtc::test::MockBlockProcessor>>
         block_processor_mock(
             new StrictMock<webrtc::test::MockBlockProcessor>());
     EXPECT_CALL(*block_processor_mock, BufferRender(_))
-        .Times(expected_num_block_to_process);
+        .Times(expected_num_block_to_process)
+        .WillRepeatedly(Return(true));
     EXPECT_CALL(*block_processor_mock, ProcessCapture(_, _, _))
         .Times(expected_num_block_to_process);
 
     switch (leakage_report_variant) {
       case EchoLeakageTestVariant::kNone:
-        EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(_)).Times(0);
+        EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(_)).Times(0);
         break;
       case EchoLeakageTestVariant::kFalseSticky:
-        EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(false)).Times(1);
+        EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(false))
+            .Times(1);
         break;
       case EchoLeakageTestVariant::kTrueSticky:
-        EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(true)).Times(1);
+        EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(true))
+            .Times(1);
         break;
       case EchoLeakageTestVariant::kTrueNonSticky: {
         testing::InSequence s;
-        EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(true)).Times(1);
-        EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(false))
+        EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(true))
+            .Times(1);
+        EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(false))
             .Times(kNumFramesToProcess - 1);
       } break;
     }
 
     EchoCanceller3 aec3(sample_rate_hz_, false,
                         std::move(block_processor_mock));
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       switch (leakage_report_variant) {
         case EchoLeakageTestVariant::kNone:
           break;
         case EchoLeakageTestVariant::kFalseSticky:
           if (frame_index == 0) {
-            aec3.ReportEchoLeakage(false);
+            aec3.UpdateEchoLeakageStatus(false);
           }
           break;
         case EchoLeakageTestVariant::kTrueSticky:
           if (frame_index == 0) {
-            aec3.ReportEchoLeakage(true);
+            aec3.UpdateEchoLeakageStatus(true);
           }
           break;
         case EchoLeakageTestVariant::kTrueNonSticky:
           if (frame_index == 0) {
-            aec3.ReportEchoLeakage(true);
+            aec3.UpdateEchoLeakageStatus(true);
           } else {
-            aec3.ReportEchoLeakage(false);
+            aec3.UpdateEchoLeakageStatus(false);
           }
           break;
       }
 
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
@@ skipping 22 matching lines @@
     const size_t num_full_blocks_per_frame =
         rtc::CheckedDivExact(LowestBandRate(sample_rate_hz_), 100) / kBlockSize;
     const size_t expected_num_block_to_process =
         (kNumFramesToProcess *
          rtc::CheckedDivExact(LowestBandRate(sample_rate_hz_), 100)) /
         kBlockSize;
     std::unique_ptr<testing::StrictMock<webrtc::test::MockBlockProcessor>>
         block_processor_mock(
             new StrictMock<webrtc::test::MockBlockProcessor>());
     EXPECT_CALL(*block_processor_mock, BufferRender(_))
-        .Times(expected_num_block_to_process);
-    EXPECT_CALL(*block_processor_mock, ReportEchoLeakage(_)).Times(0);
+        .Times(expected_num_block_to_process)
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(_)).Times(0);
 
     switch (saturation_variant) {
       case SaturationTestVariant::kNone:
         EXPECT_CALL(*block_processor_mock, ProcessCapture(_, false, _))
             .Times(expected_num_block_to_process);
         break;
       case SaturationTestVariant::kOneNegative: {
         testing::InSequence s;
         EXPECT_CALL(*block_processor_mock, ProcessCapture(_, true, _))
             .Times(num_full_blocks_per_frame);
@@ skipping 312 matching lines @@
 
 // Verifiers that the verification for null input to the capture processing api
 // call works.
 TEST(EchoCanceller3InputCheck, NullCaptureProcessingParameter) {
   EXPECT_DEATH(EchoCanceller3(8000, false).ProcessCapture(nullptr, false), "");
 }
 
 #endif
 
 }  // namespace webrtc