Introduced the new parameter setting scheme for activating the high-pass filter in APM

webrtc/modules/audio_processing/low_cut_filter_unittest.cc

 /*
  *  Copyright (c) 2015 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 <vector>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
-#include "webrtc/modules/audio_processing/high_pass_filter_impl.h"
+#include "webrtc/modules/audio_processing/low_cut_filter.h"
 #include "webrtc/modules/audio_processing/test/audio_buffer_tools.h"
 #include "webrtc/modules/audio_processing/test/bitexactness_tools.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 
 // Process one frame of data and produce the output.
 std::vector<float> ProcessOneFrame(const std::vector<float>& frame_input,
                                    const StreamConfig& stream_config,
-                                   HighPassFilterImpl* high_pass_filter) {
+                                   LowCutFilter* low_cut_filter) {
   AudioBuffer audio_buffer(
       stream_config.num_frames(), stream_config.num_channels(),
       stream_config.num_frames(), stream_config.num_channels(),
       stream_config.num_frames());
 
   test::CopyVectorToAudioBuffer(stream_config, frame_input, &audio_buffer);
-  high_pass_filter->ProcessCaptureAudio(&audio_buffer);
+  low_cut_filter->Process(&audio_buffer);
   std::vector<float> frame_output;
   test::ExtractVectorFromAudioBuffer(stream_config, &audio_buffer,
                                      &frame_output);
   return frame_output;
 }
 
 // Processes a specified amount of frames, verifies the results and reports
 // any errors.
 void RunBitexactnessTest(int sample_rate,
                          int num_channels,
                          const std::vector<float>& input,
                          const std::vector<float>& reference) {
   const StreamConfig stream_config(sample_rate, num_channels, false);
-  rtc::CriticalSection crit;
-  HighPassFilterImpl high_pass_filter(&crit);
-
-  high_pass_filter.Initialize(num_channels, sample_rate);
-  high_pass_filter.Enable(true);
+  LowCutFilter low_cut_filter(num_channels, sample_rate);
 
   std::vector<float> output;
   const size_t num_frames_to_process =
       input.size() /
       (stream_config.num_frames() * stream_config.num_channels());
   for (size_t frame_no = 0; frame_no < num_frames_to_process; ++frame_no) {
     std::vector<float> frame_input(
         input.begin() +
             stream_config.num_frames() * stream_config.num_channels() *
                 frame_no,
         input.begin() +
             stream_config.num_frames() * stream_config.num_channels() *
                 (frame_no + 1));
 
-    output = ProcessOneFrame(frame_input, stream_config, &high_pass_filter);
+    output = ProcessOneFrame(frame_input, stream_config, &low_cut_filter);
   }
 
   // Form vector to compare the reference to. Only the last frame processed
   // is compared in order not having to specify all preceeding frames as
   // inputs. As the algorithm being tested has a memory, testing only
   // the last frame implicitly also tests the preceeding frames.
   const size_t reference_frame_length =
       reference.size() / stream_config.num_channels();
   std::vector<float> output_to_verify;
   for (size_t channel_no = 0; channel_no < stream_config.num_channels();
@@ skipping 15 matching lines @@
 // TODO(peah): Remove once braced initialization is allowed.
 std::vector<float> CreateVector(const rtc::ArrayView<const float>& array_view) {
   std::vector<float> v;
   for (auto value : array_view) {
     v.push_back(value);
   }
   return v;
 }
 }  // namespace
 
-TEST(HighPassFilterBitExactnessTest, Mono8kHzInitial) {
+TEST(LowCutFilterBitExactnessTest, Mono8kHzInitial) {
   const float kReferenceInput[] = {
       0.153442f,  -0.436920f, -0.057602f, -0.141767f, 0.108608f,  0.116834f,
       0.114979f,  -0.103151f, -0.169925f, -0.167180f, 0.242024f,  -0.525426f,
       -0.058781f, 0.076667f,  -0.185095f, 0.135319f,  -0.020223f, -0.266058f,
       0.045755f,  -0.076044f, -0.116221f, -0.201698f, 0.017423f,  -0.523475f,
       -0.112949f, -0.154125f, -0.258572f, 0.185075f,  -0.208205f, 0.153298f,
       0.276703f,  -0.044481f, 0.078771f,  0.181337f,  -0.022962f, 0.153365f,
       -0.358004f, 0.314864f,  -0.280593f, -0.518572f, 0.392579f,  -0.017786f,
       0.127293f,  -0.103003f, -0.289389f, -0.871355f, 0.177583f,  -0.081290f,
       -0.055957f, 0.115011f,  -0.402460f, -0.206836f, 0.325328f,  0.169526f,
       -0.363311f, -0.624742f, -0.161979f, 0.060679f,  0.267214f,  0.026576f,
       -0.318235f, 0.086812f,  -0.332419f, -0.272485f, -0.185369f, -0.348598f,
       -0.076833f, -0.255184f, -0.081007f, -0.131121f, -0.116196f, -0.142780f,
       0.349705f,  0.173054f,  0.016750f,  -0.415957f, -0.461001f, -0.557111f,
       0.738711f,  0.275720f};
 
   const float kReference[] = {0.142277f,  -0.418518f, -0.028229f, -0.102112f,
                               0.141270f,  0.137791f,  0.124577f,  -0.088715f,
                               -0.142273f, -0.125885f, 0.266640f,  -0.468079f};
 
   RunBitexactnessTest(
       8000, 1, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Mono8kHzConverged) {
+TEST(LowCutFilterBitExactnessTest, Mono8kHzConverged) {
   const float kReferenceInput[] = {
       0.153442f,  -0.436920f, -0.057602f, -0.141767f, 0.108608f,  0.116834f,
       0.114979f,  -0.103151f, -0.169925f, -0.167180f, 0.242024f,  -0.525426f,
       -0.058781f, 0.076667f,  -0.185095f, 0.135319f,  -0.020223f, -0.266058f,
       0.045755f,  -0.076044f, -0.116221f, -0.201698f, 0.017423f,  -0.523475f,
       -0.112949f, -0.154125f, -0.258572f, 0.185075f,  -0.208205f, 0.153298f,
       0.276703f,  -0.044481f, 0.078771f,  0.181337f,  -0.022962f, 0.153365f,
       -0.358004f, 0.314864f,  -0.280593f, -0.518572f, 0.392579f,  -0.017786f,
       0.127293f,  -0.103003f, -0.289389f, -0.871355f, 0.177583f,  -0.081290f,
       -0.055957f, 0.115011f,  -0.402460f, -0.206836f, 0.325328f,  0.169526f,
@@ skipping 31 matching lines @@
 
   const float kReference[] = {-0.173553f, -0.265778f, 0.158757f,  -0.259399f,
                               -0.176361f, 0.192877f,  0.056825f,  0.171453f,
                               0.050752f,  -0.194580f, -0.208679f, 0.153722f};
 
   RunBitexactnessTest(
       8000, 1, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Stereo8kHzInitial) {
+TEST(LowCutFilterBitExactnessTest, Stereo8kHzInitial) {
   const float kReferenceInput[] = {
       0.790847f,  0.165037f,  0.165494f,  0.709852f,  -0.930269f, 0.770840f,
       -0.184538f, -0.927236f, 0.492296f,  -0.690342f, -0.712183f, 0.211918f,
       -0.491038f, -0.351692f, -0.196418f, -0.187253f, -0.227618f, 0.219604f,
       -0.666219f, -0.623816f, -0.810742f, -0.353627f, 0.539194f,  -0.531764f,
       0.480731f,  0.385637f,  0.648156f,  0.655955f,  -0.413264f, -0.381262f,
       0.046060f,  -0.349402f, 0.663685f,  0.620590f,  0.113997f,  -0.474072f,
       0.361132f,  -0.532694f, -0.087149f, -0.230866f, 0.077203f,  0.983407f,
       0.510441f,  0.960910f,  -0.530435f, 0.057118f,  -0.897128f, 0.513751f,
       0.203960f,  0.714337f,  0.976554f,  0.858969f,  -0.180970f, -0.999317f,
@@ skipping 20 matching lines @@
       0.733329f,  0.084109f,  0.072695f,  0.566210f,  -1.000000f, 0.652120f,
       -0.297424f, -0.964020f, 0.438551f,  -0.698364f, -0.654449f, 0.266243f,
       0.454115f,  0.684774f,  -0.586823f, -0.747345f, -0.503021f, -0.222961f,
       -0.314972f, 0.907224f,  -0.796265f, 0.284280f,  -0.533417f, 0.773980f};
 
   RunBitexactnessTest(
       8000, 2, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Stereo8kHzConverged) {
+TEST(LowCutFilterBitExactnessTest, Stereo8kHzConverged) {
   const float kReferenceInput[] = {
       -0.502095f, -0.227154f, -0.137133f, 0.661773f,  0.649294f,  -0.094003f,
       -0.238880f, 0.851737f,  0.481687f,  0.475266f,  0.893832f,  0.020199f,
       0.583758f,  -0.095653f, 0.698397f,  -0.219138f, 0.476753f,  0.952877f,
       0.046598f,  -0.140169f, -0.585684f, -0.353197f, -0.778260f, -0.249580f,
       -0.340192f, -0.315790f, 0.634238f,  0.063371f,  0.042244f,  0.548619f,
       -0.759474f, 0.250900f,  -0.306703f, -0.330761f, 0.149233f,  0.727875f,
       -0.602874f, 0.344902f,  0.803663f,  -0.601686f, -0.403432f, -0.006959f,
       0.779808f,  0.002829f,  -0.446010f, 0.067916f,  0.148499f,  -0.174391f,
       -0.970473f, 0.405530f,  0.013494f,  -0.237468f, -0.870137f, -0.282840f,
@@ skipping 73 matching lines @@
       -0.544495f, 0.264199f, 0.647938f,  0.565569f,  0.496231f,  0.271340f,
       0.519944f,  0.318094f, -0.792999f, 0.733421f,  -1.000000f, 0.103977f,
       0.981719f,  0.314859f, 0.476882f,  0.514267f,  -0.196381f, -0.425781f,
       -0.783081f, 0.101108f, 0.419782f,  -0.291718f, 0.183355f,  -0.332489f};
 
   RunBitexactnessTest(
       8000, 2, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Mono16kHzInitial) {
+TEST(LowCutFilterBitExactnessTest, Mono16kHzInitial) {
   const float kReferenceInput[] = {
       0.150254f,  0.512488f,  -0.631245f, 0.240938f,  0.089080f,  -0.365440f,
       -0.121169f, 0.095748f,  1.000000f,  0.773932f,  -0.377232f, 0.848124f,
       0.202718f,  -0.017621f, 0.199738f,  -0.057279f, -0.034693f, 0.416303f,
       0.393761f,  0.396041f,  0.187653f,  -0.337438f, 0.200436f,  0.455577f,
       0.136624f,  0.289150f,  0.203131f,  -0.084798f, 0.082124f,  -0.220010f,
       0.248266f,  -0.320554f, -0.298701f, -0.226218f, -0.822794f, 0.401962f,
       0.090876f,  -0.210968f, 0.382936f,  -0.478291f, -0.028572f, -0.067474f,
       0.089204f,  0.087430f,  -0.241695f, -0.008398f, -0.046076f, 0.175416f,
       0.305518f,  0.309992f,  -0.241352f, 0.021618f,  -0.339291f, -0.311173f,
@@ skipping 18 matching lines @@
 
   const float kReference[] = {0.147160f, 0.495163f,  -0.648346f, 0.234931f,
                               0.075289f, -0.373779f, -0.117676f, 0.100345f,
                               0.981719f, 0.714896f,  -0.447357f, 0.770867f};
 
   RunBitexactnessTest(
       16000, 1, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Mono16kHzConverged) {
+TEST(LowCutFilterBitExactnessTest, Mono16kHzConverged) {
   const float kReferenceInput[] = {
       0.150254f,  0.512488f,  -0.631245f, 0.240938f,  0.089080f,  -0.365440f,
       -0.121169f, 0.095748f,  1.000000f,  0.773932f,  -0.377232f, 0.848124f,
       0.202718f,  -0.017621f, 0.199738f,  -0.057279f, -0.034693f, 0.416303f,
       0.393761f,  0.396041f,  0.187653f,  -0.337438f, 0.200436f,  0.455577f,
       0.136624f,  0.289150f,  0.203131f,  -0.084798f, 0.082124f,  -0.220010f,
       0.248266f,  -0.320554f, -0.298701f, -0.226218f, -0.822794f, 0.401962f,
       0.090876f,  -0.210968f, 0.382936f,  -0.478291f, -0.028572f, -0.067474f,
       0.089204f,  0.087430f,  -0.241695f, -0.008398f, -0.046076f, 0.175416f,
       0.305518f,  0.309992f,  -0.241352f, 0.021618f,  -0.339291f, -0.311173f,
@@ skipping 71 matching lines @@
 
   const float kReference[] = {-0.248962f, -0.088257f, 0.083041f,  -0.037323f,
                               0.127659f,  0.149388f,  -0.220978f, -0.004242f,
                               -0.538544f, 0.384289f,  -0.117615f, -0.268524f};
 
   RunBitexactnessTest(
       16000, 1, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Stereo16kHzInitial) {
+TEST(LowCutFilterBitExactnessTest, Stereo16kHzInitial) {
   const float kReferenceInput[] = {
       0.087390f,  -0.370759f, -0.235918f, 0.583079f,  0.678359f,  0.360473f,
       -0.166156f, 0.285780f,  -0.571837f, 0.234542f,  0.350382f,  0.202047f,
       -0.307381f, -0.271197f, -0.657038f, 0.590723f,  -0.014666f, -0.290754f,
       0.550122f,  -0.526390f, 0.689667f,  0.633054f,  0.692457f,  -0.259626f,
       -0.233541f, 0.722669f,  -0.072182f, 0.141096f,  0.390614f,  0.921835f,
       0.092626f,  0.273153f,  0.141785f,  0.854224f,  0.727531f,  -0.660321f,
       -0.642602f, -0.512991f, 0.503559f,  -0.601731f, 0.965881f,  0.419277f,
       -0.649128f, 0.716595f,  0.818823f,  0.923326f,  0.141199f,  0.125758f,
       -0.646678f, 0.027358f,  0.096944f,  -0.669445f, -0.012214f, 0.070235f,
@@ skipping 47 matching lines @@
       0.085604f,  -0.367126f, -0.218170f, 0.594653f,  0.661245f,  0.319041f,
       -0.212891f, 0.237800f,  -0.614716f, 0.201758f,  0.305032f,  0.144414f,
       -0.936523f, 0.647359f,  -0.613403f, -0.611542f, -0.549835f, 0.477004f,
       -0.477386f, -0.287262f, 0.650746f,  0.101169f,  0.899258f,  -0.808014f};
 
   RunBitexactnessTest(
       16000, 2, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 
-TEST(HighPassFilterBitExactnessTest, Stereo16kHzConverged) {
+TEST(LowCutFilterBitExactnessTest, Stereo16kHzConverged) {
   const float kReferenceInput[] = {
       -0.145875f, 0.910744f,  0.448494f,  0.161783f,  0.080516f,  0.410882f,
       -0.989942f, 0.565032f,  0.853719f,  -0.983409f, 0.649257f,  0.534672f,
       0.994274f,  -0.544694f, 0.839084f,  0.283999f,  -0.789360f, -0.463678f,
       0.527688f,  0.611020f,  -0.791494f, -0.060482f, -0.561876f, 0.845416f,
       -0.359355f, 0.715088f,  -0.480307f, 0.756126f,  -0.623465f, 0.518388f,
       -0.936621f, 0.284678f,  0.133742f,  -0.247181f, -0.574903f, 0.584314f,
       -0.709113f, -0.021715f, -0.974309f, -0.626776f, -0.029539f, 0.676452f,
       -0.717886f, 0.464434f,  0.382134f,  -0.931015f, -0.022285f, 0.942781f,
       -0.775097f, 0.486428f,  0.277083f,  0.188366f,  -0.002755f, 0.135705f,
@@ skipping 153 matching lines @@
       -0.816528f, 0.085421f,  0.739647f,  -0.922089f, 0.669301f,  -0.048187f,
       -0.290039f, -0.818085f, -0.596008f, -0.177826f, -0.002197f, -0.350647f,
       -0.064301f, 0.337291f,  -0.621765f, 0.115909f,  0.311899f,  -0.915924f,
       0.020478f,  0.836055f,  -0.714020f, -0.037140f, 0.391125f,  -0.340118f};
 
   RunBitexactnessTest(
       16000, 2, CreateVector(rtc::ArrayView<const float>(kReferenceInput)),
       CreateVector(rtc::ArrayView<const float>(kReference)));
 }
 }  // namespace webrtc