Added first layer of the echo canceller 3 functionality

webrtc/modules/audio_processing/aec3/frame_blocker_unittest.cc

Index: webrtc/modules/audio_processing/aec3/frame_blocker_unittest.cc
diff --git a/webrtc/modules/audio_processing/aec3/frame_blocker_unittest.cc b/webrtc/modules/audio_processing/aec3/frame_blocker_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8b8c50e5846d76dc1f72842ddd9ce8d3e5c8388e
--- /dev/null
+++ b/webrtc/modules/audio_processing/aec3/frame_blocker_unittest.cc
@@ -0,0 +1,180 @@
+/*
+ *  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 <string>
+#include <vector>
+
+#include "webrtc/modules/audio_processing/aec3/aec3_constants.h"
+#include "webrtc/modules/audio_processing/aec3/block_framer.h"
+#include "webrtc/modules/audio_processing/aec3/frame_blocker.h"

[hlundin-webrtc, 2016/12/22 10:23:57]

To the top.

[peah-webrtc, 2016/12/22 16:40:04]

Done.

+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+namespace {
+
+float ComputeSampleValue(size_t chunk_counter,
+                         size_t chunk_size,
+                         size_t band,
+                         size_t sample_index,
+                         int offset) {
+  float value =
+      static_cast<int>(chunk_counter * chunk_size + sample_index) + offset;
+  return value > 0 ? 5000 * band + value : 0;
+}
+
+void FillSubFrame(size_t sub_frame_counter,
+                  int offset,
+                  std::vector<std::vector<float>>* sub_frame) {
+  for (size_t k = 0; k < sub_frame->size(); ++k) {
+    for (size_t i = 0; i < (*sub_frame)[0].size(); ++i) {
+      (*sub_frame)[k][i] =
+          ComputeSampleValue(sub_frame_counter, kSubFrameLength, k, i, offset);
+    }
+  }
+}
+
+void FillSubFrameView(size_t sub_frame_counter,
+                      int offset,
+                      std::vector<std::vector<float>>* sub_frame,
+                      std::vector<rtc::ArrayView<float>>* sub_frame_view) {
+  FillSubFrame(sub_frame_counter, offset, sub_frame);
+  for (size_t k = 0; k < sub_frame_view->size(); ++k) {
+    (*sub_frame_view)[k] =
+        rtc::ArrayView<float>(&(*sub_frame)[k][0], (*sub_frame)[k].size());
+  }
+}
+
+bool VerifySubFrame(size_t sub_frame_counter,
+                    int offset,
+                    const std::vector<rtc::ArrayView<float>>& sub_frame_view) {
+  std::vector<std::vector<float>> reference_sub_frame(
+      sub_frame_view.size(), std::vector<float>(sub_frame_view[0].size(), 0.f));
+  FillSubFrame(sub_frame_counter, offset, &reference_sub_frame);
+  for (size_t k = 0; k < sub_frame_view.size(); ++k) {
+    for (size_t i = 0; i < sub_frame_view[k].size(); ++i) {
+      if (reference_sub_frame[k][i] != sub_frame_view[k][i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool VerifyBlock(size_t block_counter,
+                 int offset,
+                 const std::vector<std::vector<float>>& block) {
+  for (size_t k = 0; k < block.size(); ++k) {
+    for (size_t i = 0; i < block[k].size(); ++i) {
+      const float reference_value =
+          ComputeSampleValue(block_counter, kBlockSize, k, i, offset);
+      if (reference_value != block[k][i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// Verifies that the FrameBlocker properly forms blocks out ouf the frames.

[hlundin-webrtc, 2016/12/22 10:23:57]

ouf?

[peah-webrtc, 2016/12/22 16:40:04]

Done.

+void RunBlockerTest(int sample_rate_hz) {
+  const size_t kNumSubFramesToProcess = 20;

[hlundin-webrtc, 2016/12/22 10:23:57]

constexpr

[peah-webrtc, 2016/12/22 16:40:04]

Done.

+  const size_t num_bands = NumBandsForRate(sample_rate_hz);
+
+  std::vector<std::vector<float>> block(num_bands,
+                                        std::vector<float>(kBlockSize, 0.f));
+  std::vector<std::vector<float>> input_sub_frame(
+      num_bands, std::vector<float>(kSubFrameLength, 0.f));
+  std::vector<rtc::ArrayView<float>> input_sub_frame_view(num_bands);
+  FrameBlocker blocker(num_bands);
+
+  size_t block_counter = 0;
+  for (size_t sub_frame_index = 0; sub_frame_index < kNumSubFramesToProcess;
+       ++sub_frame_index) {
+    FillSubFrameView(sub_frame_index, 0, &input_sub_frame,
+                     &input_sub_frame_view);
+
+    blocker.InsertSubFrameAndExtractBlock(input_sub_frame_view, &block);
+    VerifyBlock(block_counter++, 0, block);
+
+    if ((sub_frame_index + 1) % 4 == 0) {
+      EXPECT_TRUE(blocker.IsBlockAvailable());
+    } else {
+      EXPECT_FALSE(blocker.IsBlockAvailable());
+    }
+    if (blocker.IsBlockAvailable()) {
+      blocker.ExtractBlock(&block);
+      VerifyBlock(block_counter++, 0, block);
+    }
+  }
+}
+
+// Verifies that the FrameBlocker and BlockFramer work well together and produce
+// the expected output.
+void RunBlockerAndFramerTest(int sample_rate_hz) {
+  const size_t kNumSubFramesToProcess = 20;
+  const size_t num_bands = NumBandsForRate(sample_rate_hz);
+
+  std::vector<std::vector<float>> block(num_bands,
+                                        std::vector<float>(kBlockSize, 0.f));
+  std::vector<std::vector<float>> input_sub_frame(
+      num_bands, std::vector<float>(kSubFrameLength, 0.f));
+  std::vector<std::vector<float>> output_sub_frame(
+      num_bands, std::vector<float>(kSubFrameLength, 0.f));
+  std::vector<rtc::ArrayView<float>> output_sub_frame_view(num_bands);
+  std::vector<rtc::ArrayView<float>> input_sub_frame_view(num_bands);
+  FrameBlocker blocker(num_bands);
+  BlockFramer framer(num_bands);
+
+  for (size_t sub_frame_index = 0; sub_frame_index < kNumSubFramesToProcess;
+       ++sub_frame_index) {
+    FillSubFrameView(sub_frame_index, 0, &input_sub_frame,
+                     &input_sub_frame_view);
+    FillSubFrameView(sub_frame_index, 0, &output_sub_frame,
+                     &output_sub_frame_view);
+
+    blocker.InsertSubFrameAndExtractBlock(input_sub_frame_view, &block);
+    framer.InsertBlockAndExtractSubFrame(block, &output_sub_frame_view);
+
+    if ((sub_frame_index + 1) % 4 == 0) {
+      EXPECT_TRUE(blocker.IsBlockAvailable());
+    } else {
+      EXPECT_FALSE(blocker.IsBlockAvailable());
+    }
+    if (blocker.IsBlockAvailable()) {
+      blocker.ExtractBlock(&block);
+      framer.InsertBlock(block);
+    }
+    EXPECT_TRUE(VerifySubFrame(sub_frame_index, -64, output_sub_frame_view));
+  }
+}
+
+}  // namespace
+
+TEST(FrameBlocker, BlockBitexactness) {
+  for (auto rate : {8000, 16000, 32000, 48000}) {
+    std::ostringstream ss;
+    ss << "Sample rate: " << rate;
+    SCOPED_TRACE(ss.str());
+
+    RunBlockerTest(rate);
+  }
+}
+
+TEST(FrameBlocker, BlockerAndFramer) {
+  for (auto rate : {8000, 16000, 32000, 48000}) {
+    std::ostringstream ss;
+    ss << "Sample rate: " << rate;
+    SCOPED_TRACE(ss.str());
+
+    RunBlockerAndFramerTest(rate);
+  }
+}
+

[hlundin-webrtc, 2016/12/22 10:23:57]

Add some (death) tests to verify that things blow up when the calling sequence
to the blocker is wrong.

[peah-webrtc, 2016/12/22 16:40:04]

Done.

+}  // namespace webrtc