Major AEC3 render pipeline changes

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 68 matching lines @@
     for (size_t i = 0; i < frame_length; ++i) {
       if (reference_frame[k][i] != frame[k][i]) {
         return false;
       }
     }
   }
 
   return true;
 }
 
-// Verifies the that samples in the output frame are identical to the samples
-// that were produced for the input frame, with an offset in order to compensate
-// for buffering delays.
-bool VerifyOutputFrameBitexactness(size_t frame_length,
-                                   size_t frame_index,
-                                   const float* const* frame,
-                                   int offset) {
-  float reference_frame[480];
-
-  PopulateInputFrame(frame_length, frame_index, reference_frame, offset);
-  for (size_t i = 0; i < frame_length; ++i) {
-    if (reference_frame[i] != frame[0][i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 // 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 level_change,
                       bool saturated_microphone_signal,
                       std::vector<std::vector<float>>* capture_block) override {
   }
 
-  bool BufferRender(std::vector<std::vector<float>>* block) override {
-    return true;
-  }
+  void BufferRender(const std::vector<std::vector<float>>& block) 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 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 true;
+  void BufferRender(const std::vector<std::vector<float>>& block) override {
+    received_render_blocks_.push_back(block);
   }
 
   void UpdateEchoLeakageStatus(bool leakage_detected) override {}
 
  private:
   std::deque<std::vector<std::vector<float>>> received_render_blocks_;
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RenderTransportVerificationProcessor);
 };
 
 class EchoCanceller3Tester {
@@ skipping 25 matching lines @@
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
                          &render_buffer_.channels_f()[0][0], 0);
 
-      EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+      aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
           frame_length_, num_bands_, frame_index,
           &capture_buffer_.split_bands_f(0)[0], -64));
     }
   }
 
   // Test method for testing that the render data is properly received by the
   // block processor.
   void RunRenderTransportVerificationTest() {
     EchoCanceller3 aec3(
         sample_rate_hz_, false,
         std::unique_ptr<BlockProcessor>(
             new RenderTransportVerificationProcessor(num_bands_)));
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 100);
-      PopulateInputFrame(frame_length_, frame_index,
-                         &render_buffer_.channels_f()[0][0], 0);
+      PopulateInputFrame(frame_length_, num_bands_, frame_index,
+                         &render_buffer_.split_bands_f(0)[0], 0);
 
-      EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+      aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
-          frame_length_, frame_index, &capture_buffer_.split_bands_f(0)[0],
-          -64));
+          frame_length_, num_bands_, frame_index,
+          &capture_buffer_.split_bands_f(0)[0], -64));
     }
   }
 
   // Verifies that information about echo path changes are properly propagated
   // to the block processor.
   // The cases tested are:
   // -That no set echo path change flags are received when there is no echo path
   // change.
   // -That set echo path change flags are received and continues to be received
   // as long as echo path changes are flagged.
   // -That set echo path change flags are no longer received when echo path
   // change events stop being flagged.
   enum class EchoPathChangeTestVariant { kNone, kOneSticky, kOneNonSticky };
 
   void RunEchoPathChangeVerificationTest(
       EchoPathChangeTestVariant echo_path_change_test_variant) {
     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)
-        .WillRepeatedly(Return(true));
+        .Times(expected_num_block_to_process);
     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);
@@ skipping 26 matching lines @@
       }
 
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
                          &render_buffer_.channels_f()[0][0], 0);
 
-      EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+      aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, echo_path_change);
     }
   }
 
   // Test for verifying that echo leakage information is being properly passed
   // to the processor.
   // The cases tested are:
   // -That no method calls are received when they should not.
   // -That false values are received each time they are flagged.
   // -That true values are received each time they are flagged.
   // -That a false value is received when flagged after a true value has been
   // flagged.
   enum class EchoLeakageTestVariant {
     kNone,
     kFalseSticky,
     kTrueSticky,
     kTrueNonSticky
   };
 
   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)
-        .WillRepeatedly(Return(true));
+        .Times(expected_num_block_to_process);
     EXPECT_CALL(*block_processor_mock, ProcessCapture(_, _, _))
         .Times(expected_num_block_to_process);
 
     switch (leakage_report_variant) {
       case EchoLeakageTestVariant::kNone:
         EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(_)).Times(0);
         break;
       case EchoLeakageTestVariant::kFalseSticky:
         EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(false))
             .Times(1);
@@ skipping 39 matching lines @@
       }
 
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
                          &render_buffer_.channels_f()[0][0], 0);
 
-      EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+      aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
     }
   }
 
   // This verifies that saturation information is properly passed to the
   // BlockProcessor.
   // The cases tested are:
   // -That no saturation event is passed to the processor if there is no
   // saturation.
   // -That one frame with one negative saturated sample value is reported to be
   // saturated and that following non-saturated frames are properly reported as
   // not being saturated.
   // -That one frame with one positive saturated sample value is reported to be
   // saturated and that following non-saturated frames are properly reported as
   // not being saturated.
   enum class SaturationTestVariant { kNone, kOneNegative, kOnePositive };
 
   void RunCaptureSaturationVerificationTest(
       SaturationTestVariant saturation_variant) {
     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)
-        .WillRepeatedly(Return(true));
+        .Times(expected_num_block_to_process);
     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, _))
@@ skipping 30 matching lines @@
             capture_buffer_.channels_f()[0][10] = 32767.f;
           }
           break;
       }
 
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
-      PopulateInputFrame(frame_length_, frame_index,
-                         &render_buffer_.channels_f()[0][0], 0);
+      PopulateInputFrame(frame_length_, num_bands_, frame_index,
+                         &render_buffer_.split_bands_f(0)[0], 0);
 
-      EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+      aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
     }
   }
 
   // This test verifies that the swapqueue is able to handle jitter in the
   // capture and render API calls.
   void RunRenderSwapQueueVerificationTest() {
     EchoCanceller3 aec3(
         sample_rate_hz_, false,
         std::unique_ptr<BlockProcessor>(
             new RenderTransportVerificationProcessor(num_bands_)));
 
-    constexpr size_t kSwapQueueLength = 30;
-    for (size_t frame_index = 0; frame_index < kSwapQueueLength;
+    for (size_t frame_index = 0; frame_index < kRenderTransferQueueSize;
          ++frame_index) {
       if (sample_rate_hz_ > 16000) {
         render_buffer_.SplitIntoFrequencyBands();
       }
-      PopulateInputFrame(frame_length_, frame_index,
-                         &render_buffer_.channels_f()[0][0], 0);
+      PopulateInputFrame(frame_length_, num_bands_, frame_index,
+                         &render_buffer_.split_bands_f(0)[0], 0);
 
-      EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+      if (sample_rate_hz_ > 16000) {
+        render_buffer_.SplitIntoFrequencyBands();
+      }
+
+      aec3.AnalyzeRender(&render_buffer_);
     }
 
-    for (size_t frame_index = 0; frame_index < kSwapQueueLength;
+    for (size_t frame_index = 0; frame_index < kRenderTransferQueueSize;
          ++frame_index) {
       aec3.AnalyzeCapture(&capture_buffer_);
       if (sample_rate_hz_ > 16000) {
         capture_buffer_.SplitIntoFrequencyBands();
       }
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
 
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
-          frame_length_, frame_index, &capture_buffer_.split_bands_f(0)[0],
-          -64));
+          frame_length_, num_bands_, frame_index,
+          &capture_buffer_.split_bands_f(0)[0], -64));
     }
   }
 
   // This test verifies that a buffer overrun in the render swapqueue is
   // properly reported.
   void RunRenderPipelineSwapQueueOverrunReturnValueTest() {
     EchoCanceller3 aec3(sample_rate_hz_, false);
 
-    constexpr size_t kSwapQueueLength = 30;
+    constexpr size_t kRenderTransferQueueSize = 30;
     for (size_t k = 0; k < 2; ++k) {
-      for (size_t frame_index = 0; frame_index < kSwapQueueLength;
+      for (size_t frame_index = 0; frame_index < kRenderTransferQueueSize;
            ++frame_index) {
         if (sample_rate_hz_ > 16000) {
           render_buffer_.SplitIntoFrequencyBands();
         }
         PopulateInputFrame(frame_length_, frame_index,
                            &render_buffer_.channels_f()[0][0], 0);
 
         if (k == 0) {
-          EXPECT_TRUE(aec3.AnalyzeRender(&render_buffer_));
+          aec3.AnalyzeRender(&render_buffer_);
         } else {
-          EXPECT_FALSE(aec3.AnalyzeRender(&render_buffer_));
+          aec3.AnalyzeRender(&render_buffer_);
         }
       }
     }
   }
 
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
   // Verifies the that the check for the number of bands in the AnalyzeRender
   // input is correct by adjusting the sample rates of EchoCanceller3 and the
   // input AudioBuffer to have a different number of bands.
   void RunAnalyzeRenderNumBandsCheckVerification() {
@@ skipping 93 matching lines @@
 }
 
 TEST(EchoCanceller3Buffering, RenderBitexactness) {
   for (auto rate : {8000, 16000, 32000, 48000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     EchoCanceller3Tester(rate).RunRenderTransportVerificationTest();
   }
 }
 
 TEST(EchoCanceller3Buffering, RenderSwapQueue) {
-  for (auto rate : {8000, 16000, 32000, 48000}) {
+  for (auto rate : {8000, 16000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     EchoCanceller3Tester(rate).RunRenderSwapQueueVerificationTest();
   }
 }
 
 TEST(EchoCanceller3Buffering, RenderSwapQueueOverrunReturnValue) {
   for (auto rate : {8000, 16000, 32000, 48000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     EchoCanceller3Tester(rate)
         .RunRenderPipelineSwapQueueOverrunReturnValueTest();
@@ skipping 77 matching lines @@
   EXPECT_DEATH(EchoCanceller3(8000, false).AnalyzeCapture(nullptr), "");
 }
 
 // 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), "");
 }
 
 // Verifies the check for correct sample rate.
-TEST(EchoCanceller3InputCheck, WrongSampleRate) {
+// TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
+// tests on test bots has been fixed.
+TEST(EchoCanceller3InputCheck, DISABLED_WrongSampleRate) {
   ApmDataDumper data_dumper(0);
   EXPECT_DEATH(EchoCanceller3(8001, false), "");
 }
 
 #endif
 
 }  // namespace webrtc