Test submission of complete AEC-dump refactoring.

webrtc/modules/audio_processing/audio_processing_unittest.cc

 /*
  *  Copyright (c) 2012 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 <math.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <queue>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/gtest_prod_util.h"
 #include "webrtc/base/ignore_wundef.h"
+#include "webrtc/base/task_queue.h"
+#include "webrtc/base/thread.h"
 #include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/common_audio/resampler/include/push_resampler.h"
 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/audio_processing_impl.h"
 #include "webrtc/modules/audio_processing/beamformer/mock_nonlinear_beamformer.h"
 #include "webrtc/modules/audio_processing/common.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/audio_processing/level_controller/level_controller_constants.h"
 #include "webrtc/modules/audio_processing/test/protobuf_utils.h"
@@ skipping 370 matching lines @@
   int output_sample_rate_hz_;
   size_t num_output_channels_;
   FILE* far_file_;
   FILE* near_file_;
   FILE* out_file_;
 };
 
 ApmTest::ApmTest()
     : output_path_(test::OutputPath()),
 #if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)
-      ref_filename_(test::ResourcePath("audio_processing/output_data_fixed",
-                                       "pb")),
+      ref_filename_(
+          test::ResourcePath("audio_processing/output_data_fixed", "pb")),
 #elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
 #if defined(WEBRTC_MAC)
       // A different file for Mac is needed because on this platform the AEC
       // constant |kFixedDelayMs| value is 20 and not 50 as it is on the rest.
-      ref_filename_(test::ResourcePath("audio_processing/output_data_mac",
-                                       "pb")),
+      ref_filename_(
+          test::ResourcePath("audio_processing/output_data_mac", "pb")),
 #else
-      ref_filename_(test::ResourcePath("audio_processing/output_data_float",
-                                       "pb")),
+      ref_filename_(
+          test::ResourcePath("audio_processing/output_data_float", "pb")),
 #endif
 #endif
       frame_(NULL),
       revframe_(NULL),
       output_sample_rate_hz_(0),
       num_output_channels_(0),
       far_file_(NULL),
       near_file_(NULL),
       out_file_(NULL) {
   Config config;
@@ skipping 140 matching lines @@
 
 void ApmTest::ProcessWithDefaultStreamParameters(AudioFrame* frame) {
   EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));
   apm_->echo_cancellation()->set_stream_drift_samples(0);
   EXPECT_EQ(apm_->kNoError,
       apm_->gain_control()->set_stream_analog_level(127));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame));
 }
 
 int ApmTest::ProcessStreamChooser(Format format) {
+  rtc::Thread::Current()->SleepMs(1);
   if (format == kIntFormat) {
     return apm_->ProcessStream(frame_);
   }
   return apm_->ProcessStream(float_cb_->channels(),
                              frame_->samples_per_channel_,
                              frame_->sample_rate_hz_,
                              LayoutFromChannels(frame_->num_channels_),
                              output_sample_rate_hz_,
                              LayoutFromChannels(num_output_channels_),
                              float_cb_->channels());
 }
 
 int ApmTest::AnalyzeReverseStreamChooser(Format format) {
+  rtc::Thread::Current()->SleepMs(1);
   if (format == kIntFormat) {
     return apm_->ProcessReverseStream(revframe_);
   }
   return apm_->AnalyzeReverseStream(
       revfloat_cb_->channels(),
       revframe_->samples_per_channel_,
       revframe_->sample_rate_hz_,
       LayoutFromChannels(revframe_->num_channels_));
 }
 
@@ skipping 1092 matching lines @@
   apm_->echo_cancellation()->set_stream_drift_samples(0);
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_FALSE(FrameDataAreEqual(*frame_, frame_copy));
 }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 void ApmTest::ProcessDebugDump(const std::string& in_filename,
                                const std::string& out_filename,
                                Format format,
                                int max_size_bytes) {
+  rtc::TaskQueue worker_queue("ApmTest_worker_queue");
   FILE* in_file = fopen(in_filename.c_str(), "rb");
   ASSERT_TRUE(in_file != NULL);
   audioproc::Event event_msg;
   bool first_init = true;
 
   while (ReadMessageFromFile(in_file, &event_msg)) {
     if (event_msg.type() == audioproc::Event::INIT) {
       const audioproc::Init msg = event_msg.init();
       int reverse_sample_rate = msg.sample_rate();
       if (msg.has_reverse_sample_rate()) {
         reverse_sample_rate = msg.reverse_sample_rate();
       }
       int output_sample_rate = msg.sample_rate();
       if (msg.has_output_sample_rate()) {
         output_sample_rate = msg.output_sample_rate();
       }
 
       Init(msg.sample_rate(),
            output_sample_rate,
            reverse_sample_rate,
            msg.num_input_channels(),
            msg.num_output_channels(),
            msg.num_reverse_channels(),
            false);
       if (first_init) {
         // StartDebugRecording() writes an additional init message. Don't start
         // recording until after the first init to avoid the extra message.
-        EXPECT_NOERR(
-            apm_->StartDebugRecording(out_filename.c_str(), max_size_bytes));
+        EXPECT_NOERR(apm_->StartDebugRecording(out_filename.c_str(),
+                                               max_size_bytes, &worker_queue));
         first_init = false;
       }
 
     } else if (event_msg.type() == audioproc::Event::REVERSE_STREAM) {
       const audioproc::ReverseStream msg = event_msg.reverse_stream();
 
       if (msg.channel_size() > 0) {
         ASSERT_EQ(revframe_->num_channels_,
                   static_cast<size_t>(msg.channel_size()));
         for (int i = 0; i < msg.channel_size(); ++i) {
@@ skipping 115 matching lines @@
   VerifyDebugDumpTest(kIntFormat);
 }
 
 TEST_F(ApmTest, VerifyDebugDumpFloat) {
   VerifyDebugDumpTest(kFloatFormat);
 }
 #endif
 
 // TODO(andrew): expand test to verify output.
 TEST_F(ApmTest, DebugDump) {
+  rtc::TaskQueue worker_queue("ApmTest_worker_queue");
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
-  EXPECT_EQ(apm_->kNullPointerError,
-            apm_->StartDebugRecording(static_cast<const char*>(NULL), -1));
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
-  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(filename.c_str(), -1));
+  EXPECT_EQ(apm_->kNoError,
+            apm_->StartDebugRecording(filename.c_str(), -1, &worker_queue));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   // Verify the file has been written.
   FILE* fid = fopen(filename.c_str(), "r");
   ASSERT_TRUE(fid != NULL);
 
   // Clean it up.
   ASSERT_EQ(0, fclose(fid));
   ASSERT_EQ(0, remove(filename.c_str()));
 #else
   EXPECT_EQ(apm_->kUnsupportedFunctionError,
             apm_->StartDebugRecording(filename.c_str(), -1));
   EXPECT_EQ(apm_->kUnsupportedFunctionError, apm_->StopDebugRecording());
 
   // Verify the file has NOT been written.
   ASSERT_TRUE(fopen(filename.c_str(), "r") == NULL);
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 // TODO(andrew): expand test to verify output.
 TEST_F(ApmTest, DebugDumpFromFileHandle) {
-  FILE* fid = NULL;
-  EXPECT_EQ(apm_->kNullPointerError, apm_->StartDebugRecording(fid, -1));
+  rtc::TaskQueue worker_queue("ApmTest_worker_queue");
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
-  fid = fopen(filename.c_str(), "w");
+  FILE* fid = fopen(filename.c_str(), "w");
   ASSERT_TRUE(fid);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
-  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(fid, -1));
+  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(fid, -1, &worker_queue));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   // Verify the file has been written.
   fid = fopen(filename.c_str(), "r");
   ASSERT_TRUE(fid != NULL);
 
   // Clean it up.
   ASSERT_EQ(0, fclose(fid));
@@ skipping 949 matching lines @@
   // TODO(peah): Remove the testing for
   // apm->capture_nonlocked_.level_controller_enabled once the value in config_
   // is instead used to activate the level controller.
   EXPECT_FALSE(apm->capture_nonlocked_.level_controller_enabled);
   EXPECT_NEAR(kTargetLcPeakLeveldBFS,
               apm->config_.level_controller.initial_peak_level_dbfs,
               std::numeric_limits<float>::epsilon());
 }
 
 }  // namespace webrtc