webrtc/modules/audio_processing/test/audio_processing_unittest.cc - Issue 1846323002: Moved the audioprocessing unittest to the audio_processing folder

Unified Diff: webrtc/modules/audio_processing/test/audio_processing_unittest.cc

Issue 1846323002: Moved the audioprocessing unittest to the audio_processing folder (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Created 4 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webrtc/modules/audio_processing/test/audio_processing_unittest.cc

diff --git a/webrtc/modules/audio_processing/test/audio_processing_unittest.cc b/webrtc/modules/audio_processing/test/audio_processing_unittest.cc

deleted file mode 100644

index 5dbfc14df2ed4d05045313adb43b954eee92410a..0000000000000000000000000000000000000000

--- a/webrtc/modules/audio_processing/test/audio_processing_unittest.cc

+++ /dev/null

@@ -1,2761 +0,0 @@

-/*

- *

- * 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/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/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/test/protobuf_utils.h"

-#include "webrtc/modules/audio_processing/test/test_utils.h"

-#include "webrtc/modules/include/module_common_types.h"

-#include "webrtc/system_wrappers/include/event_wrapper.h"

-#include "webrtc/system_wrappers/include/trace.h"

-#include "webrtc/test/testsupport/fileutils.h"

-#ifdef WEBRTC_ANDROID_PLATFORM_BUILD

-#include "gtest/gtest.h"

-#include "external/webrtc/webrtc/modules/audio_processing/test/unittest.pb.h"

-#else

-#include "testing/gtest/include/gtest/gtest.h"

-#include "webrtc/modules/audio_processing/unittest.pb.h"

-#endif

-namespace webrtc {

-namespace {

-// TODO(ekmeyerson): Switch to using StreamConfig and ProcessingConfig where

-// applicable.

-// TODO(bjornv): This is not feasible until the functionality has been

-// re-implemented; see comment at the bottom of this file. For now, the user has

-// to hard code the |write_ref_data| value.

-// When false, this will compare the output data with the results stored to

-// file. This is the typical case. When the file should be updated, it can

-// be set to true with the command-line switch --write_ref_data.

-bool write_ref_data = false;

-const google::protobuf::int32 kChannels[] = {1, 2};

-const int kSampleRates[] = {8000, 16000, 32000, 48000};

-#if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)

-// Android doesn't support 48kHz.

-const int kProcessSampleRates[] = {8000, 16000, 32000};

-#elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

-const int kProcessSampleRates[] = {8000, 16000, 32000, 48000};

-#endif

-enum StreamDirection { kForward = 0, kReverse };

-void ConvertToFloat(const int16_t* int_data, ChannelBuffer<float>* cb) {

- ChannelBuffer<int16_t> cb_int(cb->num_frames(),

- cb->num_channels());

- Deinterleave(int_data,

- cb->num_frames(),

- cb->num_channels(),

- cb_int.channels());

- for (size_t i = 0; i < cb->num_channels(); ++i) {

- S16ToFloat(cb_int.channels()[i],

- cb->num_frames(),

- cb->channels()[i]);

- }

-void ConvertToFloat(const AudioFrame& frame, ChannelBuffer<float>* cb) {

- ConvertToFloat(frame.data_, cb);

-// Number of channels including the keyboard channel.

-size_t TotalChannelsFromLayout(AudioProcessing::ChannelLayout layout) {

- switch (layout) {

- case AudioProcessing::kMono:

- return 1;

- case AudioProcessing::kMonoAndKeyboard:

- case AudioProcessing::kStereo:

- return 2;

- case AudioProcessing::kStereoAndKeyboard:

- return 3;

- }

- assert(false);

- return 0;

-int TruncateToMultipleOf10(int value) {

- return (value / 10) * 10;

-void MixStereoToMono(const float* stereo, float* mono,

- size_t samples_per_channel) {

- for (size_t i = 0; i < samples_per_channel; ++i)

- mono[i] = (stereo[i * 2] + stereo[i * 2 + 1]) / 2;

-void MixStereoToMono(const int16_t* stereo, int16_t* mono,

- size_t samples_per_channel) {

- for (size_t i = 0; i < samples_per_channel; ++i)

- mono[i] = (stereo[i * 2] + stereo[i * 2 + 1]) >> 1;

-void CopyLeftToRightChannel(int16_t* stereo, size_t samples_per_channel) {

- for (size_t i = 0; i < samples_per_channel; i++) {

- stereo[i * 2 + 1] = stereo[i * 2];

- }

-void VerifyChannelsAreEqual(int16_t* stereo, size_t samples_per_channel) {

- for (size_t i = 0; i < samples_per_channel; i++) {

- EXPECT_EQ(stereo[i * 2 + 1], stereo[i * 2]);

- }

-void SetFrameTo(AudioFrame* frame, int16_t value) {

- for (size_t i = 0; i < frame->samples_per_channel_ * frame->num_channels_;

- ++i) {

- frame->data_[i] = value;

- }

-void SetFrameTo(AudioFrame* frame, int16_t left, int16_t right) {

- ASSERT_EQ(2u, frame->num_channels_);

- for (size_t i = 0; i < frame->samples_per_channel_ * 2; i += 2) {

- frame->data_[i] = left;

- frame->data_[i + 1] = right;

- }

-void ScaleFrame(AudioFrame* frame, float scale) {

- for (size_t i = 0; i < frame->samples_per_channel_ * frame->num_channels_;

- ++i) {

- frame->data_[i] = FloatS16ToS16(frame->data_[i] * scale);

- }

-bool FrameDataAreEqual(const AudioFrame& frame1, const AudioFrame& frame2) {

- if (frame1.samples_per_channel_ != frame2.samples_per_channel_) {

- return false;

- }

- if (frame1.num_channels_ != frame2.num_channels_) {

- return false;

- }

- if (memcmp(frame1.data_, frame2.data_,

- frame1.samples_per_channel_ * frame1.num_channels_ *

- sizeof(int16_t))) {

- return false;

- }

- return true;

-void EnableAllAPComponents(AudioProcessing* ap) {

-#if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)

- EXPECT_NOERR(ap->echo_control_mobile()->Enable(true));

- EXPECT_NOERR(ap->gain_control()->set_mode(GainControl::kAdaptiveDigital));

- EXPECT_NOERR(ap->gain_control()->Enable(true));

-#elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

- EXPECT_NOERR(ap->echo_cancellation()->enable_drift_compensation(true));

- EXPECT_NOERR(ap->echo_cancellation()->enable_metrics(true));

- EXPECT_NOERR(ap->echo_cancellation()->enable_delay_logging(true));

- EXPECT_NOERR(ap->echo_cancellation()->Enable(true));

- EXPECT_NOERR(ap->gain_control()->set_mode(GainControl::kAdaptiveAnalog));

- EXPECT_NOERR(ap->gain_control()->set_analog_level_limits(0, 255));

- EXPECT_NOERR(ap->gain_control()->Enable(true));

-#endif

- EXPECT_NOERR(ap->high_pass_filter()->Enable(true));

- EXPECT_NOERR(ap->level_estimator()->Enable(true));

- EXPECT_NOERR(ap->noise_suppression()->Enable(true));

- EXPECT_NOERR(ap->voice_detection()->Enable(true));

-// These functions are only used by ApmTest.Process.

-template <class T>

-T AbsValue(T a) {

- return a > 0 ? a: -a;

-int16_t MaxAudioFrame(const AudioFrame& frame) {

- const size_t length = frame.samples_per_channel_ * frame.num_channels_;

- int16_t max_data = AbsValue(frame.data_[0]);

- for (size_t i = 1; i < length; i++) {

- max_data = std::max(max_data, AbsValue(frame.data_[i]));

- }

- return max_data;

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

-void TestStats(const AudioProcessing::Statistic& test,

- const audioproc::Test::Statistic& reference) {

- EXPECT_NEAR(reference.instant(), test.instant, 2);

- EXPECT_NEAR(reference.average(), test.average, 2);

- EXPECT_NEAR(reference.maximum(), test.maximum, 3);

- EXPECT_NEAR(reference.minimum(), test.minimum, 2);

-void WriteStatsMessage(const AudioProcessing::Statistic& output,

- audioproc::Test::Statistic* msg) {

- msg->set_instant(output.instant);

- msg->set_average(output.average);

- msg->set_maximum(output.maximum);

- msg->set_minimum(output.minimum);

-#endif

-void OpenFileAndWriteMessage(const std::string filename,

- const ::google::protobuf::MessageLite& msg) {

-#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)

- FILE* file = fopen(filename.c_str(), "wb");

- ASSERT_TRUE(file != NULL);

- int32_t size = msg.ByteSize();

- ASSERT_GT(size, 0);

- std::unique_ptr<uint8_t[]> array(new uint8_t[size]);

- ASSERT_TRUE(msg.SerializeToArray(array.get(), size));

- ASSERT_EQ(1u, fwrite(&size, sizeof(size), 1, file));

- ASSERT_EQ(static_cast<size_t>(size),

- fwrite(array.get(), sizeof(array[0]), size, file));

- fclose(file);

-#else

- std::cout << "Warning: Writing new reference is only allowed on Linux!"

- << std::endl;

-#endif

-std::string ResourceFilePath(std::string name, int sample_rate_hz) {

- std::ostringstream ss;

- // Resource files are all stereo.

- ss << name << sample_rate_hz / 1000 << "_stereo";

- return test::ResourcePath(ss.str(), "pcm");

-// Temporary filenames unique to this process. Used to be able to run these

-// tests in parallel as each process needs to be running in isolation they can't

-// have competing filenames.

-std::map<std::string, std::string> temp_filenames;

-std::string OutputFilePath(std::string name,

- int input_rate,

- int output_rate,

- int reverse_input_rate,

- int reverse_output_rate,

- size_t num_input_channels,

- size_t num_output_channels,

- size_t num_reverse_input_channels,

- size_t num_reverse_output_channels,

- StreamDirection file_direction) {

- std::ostringstream ss;

- ss << name << "_i" << num_input_channels << "_" << input_rate / 1000 << "_ir"

- << num_reverse_input_channels << "_" << reverse_input_rate / 1000 << "_";

- if (num_output_channels == 1) {

- ss << "mono";

- } else if (num_output_channels == 2) {

- ss << "stereo";

- } else {

- assert(false);

- }

- ss << output_rate / 1000;

- if (num_reverse_output_channels == 1) {

- ss << "_rmono";

- } else if (num_reverse_output_channels == 2) {

- ss << "_rstereo";

- } else {

- assert(false);

- }

- ss << reverse_output_rate / 1000;

- ss << "_d" << file_direction << "_pcm";

- std::string filename = ss.str();

- if (temp_filenames[filename].empty())

- temp_filenames[filename] = test::TempFilename(test::OutputPath(), filename);

- return temp_filenames[filename];

-void ClearTempFiles() {

- for (auto& kv : temp_filenames)

- remove(kv.second.c_str());

-void OpenFileAndReadMessage(const std::string filename,

- ::google::protobuf::MessageLite* msg) {

- FILE* file = fopen(filename.c_str(), "rb");

- ASSERT_TRUE(file != NULL);

- ReadMessageFromFile(file, msg);

- fclose(file);

-// Reads a 10 ms chunk of int16 interleaved audio from the given (assumed

-// stereo) file, converts to deinterleaved float (optionally downmixing) and

-// returns the result in |cb|. Returns false if the file ended (or on error) and

-// true otherwise.

-//

-// |int_data| and |float_data| are just temporary space that must be

-// sufficiently large to hold the 10 ms chunk.

-bool ReadChunk(FILE* file, int16_t* int_data, float* float_data,

- ChannelBuffer<float>* cb) {

- // The files always contain stereo audio.

- size_t frame_size = cb->num_frames() * 2;

- size_t read_count = fread(int_data, sizeof(int16_t), frame_size, file);

- if (read_count != frame_size) {

- // Check that the file really ended.

- assert(feof(file));

- return false; // This is expected.

- }

- S16ToFloat(int_data, frame_size, float_data);

- if (cb->num_channels() == 1) {

- MixStereoToMono(float_data, cb->channels()[0], cb->num_frames());

- } else {

- Deinterleave(float_data, cb->num_frames(), 2,

- cb->channels());

- }

- return true;

-class ApmTest : public ::testing::Test {

- protected:

- ApmTest();

- virtual void SetUp();

- virtual void TearDown();

- static void SetUpTestCase() {

- Trace::CreateTrace();

- }

- static void TearDownTestCase() {

- Trace::ReturnTrace();

- ClearTempFiles();

- }

- // Used to select between int and float interface tests.

- enum Format {

- kIntFormat,

- kFloatFormat

- };

- void Init(int sample_rate_hz,

- int output_sample_rate_hz,

- int reverse_sample_rate_hz,

- size_t num_input_channels,

- size_t num_output_channels,

- size_t num_reverse_channels,

- bool open_output_file);

- void Init(AudioProcessing* ap);

- void EnableAllComponents();

- bool ReadFrame(FILE* file, AudioFrame* frame);

- bool ReadFrame(FILE* file, AudioFrame* frame, ChannelBuffer<float>* cb);

- void ReadFrameWithRewind(FILE* file, AudioFrame* frame);

- void ReadFrameWithRewind(FILE* file, AudioFrame* frame,

- ChannelBuffer<float>* cb);

- void ProcessWithDefaultStreamParameters(AudioFrame* frame);

- void ProcessDelayVerificationTest(int delay_ms, int system_delay_ms,

- int delay_min, int delay_max);

- void TestChangingChannelsInt16Interface(

- size_t num_channels,

- AudioProcessing::Error expected_return);

- void TestChangingForwardChannels(size_t num_in_channels,

- size_t num_out_channels,

- AudioProcessing::Error expected_return);

- void TestChangingReverseChannels(size_t num_rev_channels,

- AudioProcessing::Error expected_return);

- void RunQuantizedVolumeDoesNotGetStuckTest(int sample_rate);

- void RunManualVolumeChangeIsPossibleTest(int sample_rate);

- void StreamParametersTest(Format format);

- int ProcessStreamChooser(Format format);

- int AnalyzeReverseStreamChooser(Format format);

- void ProcessDebugDump(const std::string& in_filename,

- const std::string& out_filename,

- Format format,

- int max_size_bytes);

- void VerifyDebugDumpTest(Format format);

- const std::string output_path_;

- const std::string ref_path_;

- const std::string ref_filename_;

- std::unique_ptr<AudioProcessing> apm_;

- AudioFrame* frame_;

- AudioFrame* revframe_;

- std::unique_ptr<ChannelBuffer<float> > float_cb_;

- std::unique_ptr<ChannelBuffer<float> > revfloat_cb_;

- 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()),

- ref_path_(test::ProjectRootPath() + "data/audio_processing/"),

-#if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)

- ref_filename_(ref_path_ + "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_(ref_path_ + "output_data_mac.pb"),

-#else

- ref_filename_(ref_path_ + "output_data_float.pb"),

-#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;

- config.Set<ExperimentalAgc>(new ExperimentalAgc(false));

- apm_.reset(AudioProcessing::Create(config));

-void ApmTest::SetUp() {

- ASSERT_TRUE(apm_.get() != NULL);

- frame_ = new AudioFrame();

- revframe_ = new AudioFrame();

- Init(32000, 32000, 32000, 2, 2, 2, false);

-void ApmTest::TearDown() {

- if (frame_) {

- delete frame_;

- }

- frame_ = NULL;

- if (revframe_) {

- delete revframe_;

- }

- revframe_ = NULL;

- if (far_file_) {

- ASSERT_EQ(0, fclose(far_file_));

- }

- far_file_ = NULL;

- if (near_file_) {

- ASSERT_EQ(0, fclose(near_file_));

- }

- near_file_ = NULL;

- if (out_file_) {

- ASSERT_EQ(0, fclose(out_file_));

- }

- out_file_ = NULL;

-void ApmTest::Init(AudioProcessing* ap) {

- ASSERT_EQ(kNoErr,

- ap->Initialize(

- {{{frame_->sample_rate_hz_, frame_->num_channels_},

- {output_sample_rate_hz_, num_output_channels_},

- {revframe_->sample_rate_hz_, revframe_->num_channels_},

- {revframe_->sample_rate_hz_, revframe_->num_channels_}}}));

-void ApmTest::Init(int sample_rate_hz,

- int output_sample_rate_hz,

- int reverse_sample_rate_hz,

- size_t num_input_channels,

- size_t num_output_channels,

- size_t num_reverse_channels,

- bool open_output_file) {

- SetContainerFormat(sample_rate_hz, num_input_channels, frame_, &float_cb_);

- output_sample_rate_hz_ = output_sample_rate_hz;

- num_output_channels_ = num_output_channels;

- SetContainerFormat(reverse_sample_rate_hz, num_reverse_channels, revframe_,

- &revfloat_cb_);

- Init(apm_.get());

- if (far_file_) {

- ASSERT_EQ(0, fclose(far_file_));

- }

- std::string filename = ResourceFilePath("far", sample_rate_hz);

- far_file_ = fopen(filename.c_str(), "rb");

- ASSERT_TRUE(far_file_ != NULL) << "Could not open file " <<

- filename << "\n";

- if (near_file_) {

- ASSERT_EQ(0, fclose(near_file_));

- }

- filename = ResourceFilePath("near", sample_rate_hz);

- near_file_ = fopen(filename.c_str(), "rb");

- ASSERT_TRUE(near_file_ != NULL) << "Could not open file " <<

- filename << "\n";

- if (open_output_file) {

- if (out_file_) {

- ASSERT_EQ(0, fclose(out_file_));

- }

- filename = OutputFilePath(

- "out", sample_rate_hz, output_sample_rate_hz, reverse_sample_rate_hz,

- reverse_sample_rate_hz, num_input_channels, num_output_channels,

- num_reverse_channels, num_reverse_channels, kForward);

- out_file_ = fopen(filename.c_str(), "wb");

- ASSERT_TRUE(out_file_ != NULL) << "Could not open file " <<

- filename << "\n";

- }

-void ApmTest::EnableAllComponents() {

- EnableAllAPComponents(apm_.get());

-bool ApmTest::ReadFrame(FILE* file, AudioFrame* frame,

- ChannelBuffer<float>* cb) {

- // The files always contain stereo audio.

- size_t frame_size = frame->samples_per_channel_ * 2;

- size_t read_count = fread(frame->data_,

- sizeof(int16_t),

- frame_size,

- file);

- if (read_count != frame_size) {

- // Check that the file really ended.

- EXPECT_NE(0, feof(file));

- return false; // This is expected.

- }

- if (frame->num_channels_ == 1) {

- MixStereoToMono(frame->data_, frame->data_,

- frame->samples_per_channel_);

- }

- if (cb) {

- ConvertToFloat(*frame, cb);

- }

- return true;

-bool ApmTest::ReadFrame(FILE* file, AudioFrame* frame) {

- return ReadFrame(file, frame, NULL);

-// If the end of the file has been reached, rewind it and attempt to read the

-// frame again.

-void ApmTest::ReadFrameWithRewind(FILE* file, AudioFrame* frame,

- ChannelBuffer<float>* cb) {

- if (!ReadFrame(near_file_, frame_, cb)) {

- rewind(near_file_);

- ASSERT_TRUE(ReadFrame(near_file_, frame_, cb));

- }

-void ApmTest::ReadFrameWithRewind(FILE* file, AudioFrame* frame) {

- ReadFrameWithRewind(file, frame, NULL);

-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) {

- 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) {

- 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_));

-void ApmTest::ProcessDelayVerificationTest(int delay_ms, int system_delay_ms,

- int delay_min, int delay_max) {

- // The |revframe_| and |frame_| should include the proper frame information,

- // hence can be used for extracting information.

- AudioFrame tmp_frame;

- std::queue<AudioFrame*> frame_queue;

- bool causal = true;

- tmp_frame.CopyFrom(*revframe_);

- SetFrameTo(&tmp_frame, 0);

- EXPECT_EQ(apm_->kNoError, apm_->Initialize());

- // Initialize the |frame_queue| with empty frames.

- int frame_delay = delay_ms / 10;

- while (frame_delay < 0) {

- AudioFrame* frame = new AudioFrame();

- frame->CopyFrom(tmp_frame);

- frame_queue.push(frame);

- frame_delay++;

- causal = false;

- }

- while (frame_delay > 0) {

- AudioFrame* frame = new AudioFrame();

- frame->CopyFrom(tmp_frame);

- frame_queue.push(frame);

- frame_delay--;

- }

- // Run for 4.5 seconds, skipping statistics from the first 2.5 seconds. We

- // need enough frames with audio to have reliable estimates, but as few as

- // possible to keep processing time down. 4.5 seconds seemed to be a good

- // compromise for this recording.

- for (int frame_count = 0; frame_count < 450; ++frame_count) {

- AudioFrame* frame = new AudioFrame();

- frame->CopyFrom(tmp_frame);

- // Use the near end recording, since that has more speech in it.

- ASSERT_TRUE(ReadFrame(near_file_, frame));

- frame_queue.push(frame);

- AudioFrame* reverse_frame = frame;

- AudioFrame* process_frame = frame_queue.front();

- if (!causal) {

- reverse_frame = frame_queue.front();

- // When we call ProcessStream() the frame is modified, so we can't use the

- // pointer directly when things are non-causal. Use an intermediate frame

- // and copy the data.

- process_frame = &tmp_frame;

- process_frame->CopyFrom(*frame);

- }

- EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(reverse_frame));

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(system_delay_ms));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(process_frame));

- frame = frame_queue.front();

- frame_queue.pop();

- delete frame;

- if (frame_count == 250) {

- int median;

- int std;

- float poor_fraction;

- // Discard the first delay metrics to avoid convergence effects.

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->GetDelayMetrics(&median, &std,

- &poor_fraction));

- }

- rewind(near_file_);

- while (!frame_queue.empty()) {

- AudioFrame* frame = frame_queue.front();

- frame_queue.pop();

- delete frame;

- }

- // Calculate expected delay estimate and acceptable regions. Further,

- // limit them w.r.t. AEC delay estimation support.

- const size_t samples_per_ms =

- std::min(static_cast<size_t>(16), frame_->samples_per_channel_ / 10);

- int expected_median = std::min(std::max(delay_ms - system_delay_ms,

- delay_min), delay_max);

- int expected_median_high = std::min(

- std::max(expected_median + static_cast<int>(96 / samples_per_ms),

- delay_min),

- delay_max);

- int expected_median_low = std::min(

- std::max(expected_median - static_cast<int>(96 / samples_per_ms),

- delay_min),

- delay_max);

- // Verify delay metrics.

- int median;

- int std;

- float poor_fraction;

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->GetDelayMetrics(&median, &std,

- &poor_fraction));

- EXPECT_GE(expected_median_high, median);

- EXPECT_LE(expected_median_low, median);

-void ApmTest::StreamParametersTest(Format format) {

- // No errors when the components are disabled.

- EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format));

- // -- Missing AGC level --

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // Resets after successful ProcessStream().

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(127));

- EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // Other stream parameters set correctly.

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_drift_compensation(true));

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(false));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_drift_compensation(false));

- // -- Missing delay --

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));

- EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // Resets after successful ProcessStream().

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // Other stream parameters set correctly.

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_drift_compensation(true));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(127));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(false));

- // -- Missing drift --

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // Resets after successful ProcessStream().

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // Other stream parameters set correctly.

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(127));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // -- No stream parameters --

- EXPECT_EQ(apm_->kNoError,

- AnalyzeReverseStreamChooser(format));

- EXPECT_EQ(apm_->kStreamParameterNotSetError,

- ProcessStreamChooser(format));

- // -- All there --

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(127));

- EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format));

-TEST_F(ApmTest, StreamParametersInt) {

- StreamParametersTest(kIntFormat);

-TEST_F(ApmTest, StreamParametersFloat) {

- StreamParametersTest(kFloatFormat);

-TEST_F(ApmTest, DefaultDelayOffsetIsZero) {

- EXPECT_EQ(0, apm_->delay_offset_ms());

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(50));

- EXPECT_EQ(50, apm_->stream_delay_ms());

-TEST_F(ApmTest, DelayOffsetWithLimitsIsSetProperly) {

- // High limit of 500 ms.

- apm_->set_delay_offset_ms(100);

- EXPECT_EQ(100, apm_->delay_offset_ms());

- EXPECT_EQ(apm_->kBadStreamParameterWarning, apm_->set_stream_delay_ms(450));

- EXPECT_EQ(500, apm_->stream_delay_ms());

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- EXPECT_EQ(200, apm_->stream_delay_ms());

- // Low limit of 0 ms.

- apm_->set_delay_offset_ms(-50);

- EXPECT_EQ(-50, apm_->delay_offset_ms());

- EXPECT_EQ(apm_->kBadStreamParameterWarning, apm_->set_stream_delay_ms(20));

- EXPECT_EQ(0, apm_->stream_delay_ms());

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));

- EXPECT_EQ(50, apm_->stream_delay_ms());

-void ApmTest::TestChangingChannelsInt16Interface(

- size_t num_channels,

- AudioProcessing::Error expected_return) {

- frame_->num_channels_ = num_channels;

- EXPECT_EQ(expected_return, apm_->ProcessStream(frame_));

- EXPECT_EQ(expected_return, apm_->ProcessReverseStream(frame_));

-void ApmTest::TestChangingForwardChannels(

- size_t num_in_channels,

- size_t num_out_channels,

- AudioProcessing::Error expected_return) {

- const StreamConfig input_stream = {frame_->sample_rate_hz_, num_in_channels};

- const StreamConfig output_stream = {output_sample_rate_hz_, num_out_channels};

- EXPECT_EQ(expected_return,

- apm_->ProcessStream(float_cb_->channels(), input_stream,

- output_stream, float_cb_->channels()));

-void ApmTest::TestChangingReverseChannels(

- size_t num_rev_channels,

- AudioProcessing::Error expected_return) {

- const ProcessingConfig processing_config = {

- {{frame_->sample_rate_hz_, apm_->num_input_channels()},

- {output_sample_rate_hz_, apm_->num_output_channels()},

- {frame_->sample_rate_hz_, num_rev_channels},

- {frame_->sample_rate_hz_, num_rev_channels}}};

- EXPECT_EQ(

- expected_return,

- apm_->ProcessReverseStream(

- float_cb_->channels(), processing_config.reverse_input_stream(),

- processing_config.reverse_output_stream(), float_cb_->channels()));

-TEST_F(ApmTest, ChannelsInt16Interface) {

- // Testing number of invalid and valid channels.

- Init(16000, 16000, 16000, 4, 4, 4, false);

- TestChangingChannelsInt16Interface(0, apm_->kBadNumberChannelsError);

- for (size_t i = 1; i < 4; i++) {

- TestChangingChannelsInt16Interface(i, kNoErr);

- EXPECT_EQ(i, apm_->num_input_channels());

- // We always force the number of reverse channels used for processing to 1.

- EXPECT_EQ(1u, apm_->num_reverse_channels());

- }

-TEST_F(ApmTest, Channels) {

- // Testing number of invalid and valid channels.

- Init(16000, 16000, 16000, 4, 4, 4, false);

- TestChangingForwardChannels(0, 1, apm_->kBadNumberChannelsError);

- TestChangingReverseChannels(0, apm_->kBadNumberChannelsError);

- for (size_t i = 1; i < 4; ++i) {

- for (size_t j = 0; j < 1; ++j) {

- // Output channels much be one or match input channels.

- if (j == 1 || i == j) {

- TestChangingForwardChannels(i, j, kNoErr);

- TestChangingReverseChannels(i, kNoErr);

- EXPECT_EQ(i, apm_->num_input_channels());

- EXPECT_EQ(j, apm_->num_output_channels());

- // The number of reverse channels used for processing to is always 1.

- EXPECT_EQ(1u, apm_->num_reverse_channels());

- } else {

- TestChangingForwardChannels(i, j,

- AudioProcessing::kBadNumberChannelsError);

- }

-TEST_F(ApmTest, SampleRatesInt) {

- // Testing invalid sample rates

- SetContainerFormat(10000, 2, frame_, &float_cb_);

- EXPECT_EQ(apm_->kBadSampleRateError, ProcessStreamChooser(kIntFormat));

- // Testing valid sample rates

- int fs[] = {8000, 16000, 32000, 48000};

- for (size_t i = 0; i < arraysize(fs); i++) {

- SetContainerFormat(fs[i], 2, frame_, &float_cb_);

- EXPECT_NOERR(ProcessStreamChooser(kIntFormat));

- }

-TEST_F(ApmTest, EchoCancellation) {

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_drift_compensation(true));

- EXPECT_TRUE(apm_->echo_cancellation()->is_drift_compensation_enabled());

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_drift_compensation(false));

- EXPECT_FALSE(apm_->echo_cancellation()->is_drift_compensation_enabled());

- EchoCancellation::SuppressionLevel level[] = {

- EchoCancellation::kLowSuppression,

- EchoCancellation::kModerateSuppression,

- EchoCancellation::kHighSuppression,

- };

- for (size_t i = 0; i < arraysize(level); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->set_suppression_level(level[i]));

- EXPECT_EQ(level[i],

- apm_->echo_cancellation()->suppression_level());

- }

- EchoCancellation::Metrics metrics;

- EXPECT_EQ(apm_->kNotEnabledError,

- apm_->echo_cancellation()->GetMetrics(&metrics));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_metrics(true));

- EXPECT_TRUE(apm_->echo_cancellation()->are_metrics_enabled());

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_metrics(false));

- EXPECT_FALSE(apm_->echo_cancellation()->are_metrics_enabled());

- int median = 0;

- int std = 0;

- float poor_fraction = 0;

- EXPECT_EQ(apm_->kNotEnabledError,

- apm_->echo_cancellation()->GetDelayMetrics(&median, &std,

- &poor_fraction));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_delay_logging(true));

- EXPECT_TRUE(apm_->echo_cancellation()->is_delay_logging_enabled());

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_delay_logging(false));

- EXPECT_FALSE(apm_->echo_cancellation()->is_delay_logging_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));

- EXPECT_TRUE(apm_->echo_cancellation()->is_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(false));

- EXPECT_FALSE(apm_->echo_cancellation()->is_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));

- EXPECT_TRUE(apm_->echo_cancellation()->is_enabled());

- EXPECT_TRUE(apm_->echo_cancellation()->aec_core() != NULL);

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(false));

- EXPECT_FALSE(apm_->echo_cancellation()->is_enabled());

- EXPECT_FALSE(apm_->echo_cancellation()->aec_core() != NULL);

-TEST_F(ApmTest, DISABLED_EchoCancellationReportsCorrectDelays) {

- // TODO(bjornv): Fix this test to work with DA-AEC.

- // Enable AEC only.

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_drift_compensation(false));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_metrics(false));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->enable_delay_logging(true));

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));

- Config config;

- config.Set<DelayAgnostic>(new DelayAgnostic(false));

- apm_->SetExtraOptions(config);

- // Internally in the AEC the amount of lookahead the delay estimation can

- // handle is 15 blocks and the maximum delay is set to 60 blocks.

- const int kLookaheadBlocks = 15;

- const int kMaxDelayBlocks = 60;

- // The AEC has a startup time before it actually starts to process. This

- // procedure can flush the internal far-end buffer, which of course affects

- // the delay estimation. Therefore, we set a system_delay high enough to

- // avoid that. The smallest system_delay you can report without flushing the

- // buffer is 66 ms in 8 kHz.

- //

- // It is known that for 16 kHz (and 32 kHz) sampling frequency there is an

- // additional stuffing of 8 ms on the fly, but it seems to have no impact on

- // delay estimation. This should be noted though. In case of test failure,

- // this could be the cause.

- const int kSystemDelayMs = 66;

- // Test a couple of corner cases and verify that the estimated delay is

- // within a valid region (set to +-1.5 blocks). Note that these cases are

- // sampling frequency dependent.

- for (size_t i = 0; i < arraysize(kProcessSampleRates); i++) {

- Init(kProcessSampleRates[i],

- kProcessSampleRates[i],

- 2,

- false);

- // Sampling frequency dependent variables.

- const int num_ms_per_block =

- std::max(4, static_cast<int>(640 / frame_->samples_per_channel_));

- const int delay_min_ms = -kLookaheadBlocks * num_ms_per_block;

- const int delay_max_ms = (kMaxDelayBlocks - 1) * num_ms_per_block;

- // 1) Verify correct delay estimate at lookahead boundary.

- int delay_ms = TruncateToMultipleOf10(kSystemDelayMs + delay_min_ms);

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- // 2) A delay less than maximum lookahead should give an delay estimate at

- // the boundary (= -kLookaheadBlocks * num_ms_per_block).

- delay_ms -= 20;

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- // 3) Three values around zero delay. Note that we need to compensate for

- // the fake system_delay.

- delay_ms = TruncateToMultipleOf10(kSystemDelayMs - 10);

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- delay_ms = TruncateToMultipleOf10(kSystemDelayMs);

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- delay_ms = TruncateToMultipleOf10(kSystemDelayMs + 10);

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- // 4) Verify correct delay estimate at maximum delay boundary.

- delay_ms = TruncateToMultipleOf10(kSystemDelayMs + delay_max_ms);

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- // 5) A delay above the maximum delay should give an estimate at the

- // boundary (= (kMaxDelayBlocks - 1) * num_ms_per_block).

- delay_ms += 20;

- ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,

- delay_max_ms);

- }

-TEST_F(ApmTest, EchoControlMobile) {

- // Turn AECM on (and AEC off)

- Init(16000, 16000, 16000, 2, 2, 2, false);

- EXPECT_EQ(apm_->kNoError, apm_->echo_control_mobile()->Enable(true));

- EXPECT_TRUE(apm_->echo_control_mobile()->is_enabled());

- // Toggle routing modes

- EchoControlMobile::RoutingMode mode[] = {

- EchoControlMobile::kQuietEarpieceOrHeadset,

- EchoControlMobile::kEarpiece,

- EchoControlMobile::kLoudEarpiece,

- EchoControlMobile::kSpeakerphone,

- EchoControlMobile::kLoudSpeakerphone,

- };

- for (size_t i = 0; i < arraysize(mode); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_control_mobile()->set_routing_mode(mode[i]));

- EXPECT_EQ(mode[i],

- apm_->echo_control_mobile()->routing_mode());

- }

- // Turn comfort noise off/on

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_control_mobile()->enable_comfort_noise(false));

- EXPECT_FALSE(apm_->echo_control_mobile()->is_comfort_noise_enabled());

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_control_mobile()->enable_comfort_noise(true));

- EXPECT_TRUE(apm_->echo_control_mobile()->is_comfort_noise_enabled());

- // Set and get echo path

- const size_t echo_path_size =

- apm_->echo_control_mobile()->echo_path_size_bytes();

- std::unique_ptr<char[]> echo_path_in(new char[echo_path_size]);

- std::unique_ptr<char[]> echo_path_out(new char[echo_path_size]);

- EXPECT_EQ(apm_->kNullPointerError,

- apm_->echo_control_mobile()->SetEchoPath(NULL, echo_path_size));

- EXPECT_EQ(apm_->kNullPointerError,

- apm_->echo_control_mobile()->GetEchoPath(NULL, echo_path_size));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(), 1));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(),

- echo_path_size));

- for (size_t i = 0; i < echo_path_size; i++) {

- echo_path_in[i] = echo_path_out[i] + 1;

- }

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->echo_control_mobile()->SetEchoPath(echo_path_in.get(), 1));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_control_mobile()->SetEchoPath(echo_path_in.get(),

- echo_path_size));

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(),

- echo_path_size));

- for (size_t i = 0; i < echo_path_size; i++) {

- EXPECT_EQ(echo_path_in[i], echo_path_out[i]);

- }

- // Process a few frames with NS in the default disabled state. This exercises

- // a different codepath than with it enabled.

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- // Turn AECM off

- EXPECT_EQ(apm_->kNoError, apm_->echo_control_mobile()->Enable(false));

- EXPECT_FALSE(apm_->echo_control_mobile()->is_enabled());

-TEST_F(ApmTest, GainControl) {

- // Testing gain modes

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_mode(

- apm_->gain_control()->mode()));

- GainControl::Mode mode[] = {

- GainControl::kAdaptiveAnalog,

- GainControl::kAdaptiveDigital,

- GainControl::kFixedDigital

- };

- for (size_t i = 0; i < arraysize(mode); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_mode(mode[i]));

- EXPECT_EQ(mode[i], apm_->gain_control()->mode());

- }

- // Testing invalid target levels

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_target_level_dbfs(-3));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_target_level_dbfs(-40));

- // Testing valid target levels

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_target_level_dbfs(

- apm_->gain_control()->target_level_dbfs()));

- int level_dbfs[] = {0, 6, 31};

- for (size_t i = 0; i < arraysize(level_dbfs); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_target_level_dbfs(level_dbfs[i]));

- EXPECT_EQ(level_dbfs[i], apm_->gain_control()->target_level_dbfs());

- }

- // Testing invalid compression gains

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_compression_gain_db(-1));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_compression_gain_db(100));

- // Testing valid compression gains

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_compression_gain_db(

- apm_->gain_control()->compression_gain_db()));

- int gain_db[] = {0, 10, 90};

- for (size_t i = 0; i < arraysize(gain_db); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_compression_gain_db(gain_db[i]));

- EXPECT_EQ(gain_db[i], apm_->gain_control()->compression_gain_db());

- }

- // Testing limiter off/on

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->enable_limiter(false));

- EXPECT_FALSE(apm_->gain_control()->is_limiter_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->enable_limiter(true));

- EXPECT_TRUE(apm_->gain_control()->is_limiter_enabled());

- // Testing invalid level limits

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_analog_level_limits(-1, 512));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_analog_level_limits(100000, 512));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_analog_level_limits(512, -1));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_analog_level_limits(512, 100000));

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->gain_control()->set_analog_level_limits(512, 255));

- // Testing valid level limits

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_analog_level_limits(

- apm_->gain_control()->analog_level_minimum(),

- apm_->gain_control()->analog_level_maximum()));

- int min_level[] = {0, 255, 1024};

- for (size_t i = 0; i < arraysize(min_level); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_analog_level_limits(min_level[i], 1024));

- EXPECT_EQ(min_level[i], apm_->gain_control()->analog_level_minimum());

- }

- int max_level[] = {0, 1024, 65535};

- for (size_t i = 0; i < arraysize(min_level); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_analog_level_limits(0, max_level[i]));

- EXPECT_EQ(max_level[i], apm_->gain_control()->analog_level_maximum());

- }

- // TODO(ajm): stream_is_saturated() and stream_analog_level()

- // Turn AGC off

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(false));

- EXPECT_FALSE(apm_->gain_control()->is_enabled());

-void ApmTest::RunQuantizedVolumeDoesNotGetStuckTest(int sample_rate) {

- Init(sample_rate, sample_rate, sample_rate, 2, 2, 2, false);

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_mode(GainControl::kAdaptiveAnalog));

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));

- int out_analog_level = 0;

- for (int i = 0; i < 2000; ++i) {

- ReadFrameWithRewind(near_file_, frame_);

- // Ensure the audio is at a low level, so the AGC will try to increase it.

- ScaleFrame(frame_, 0.25);

- // Always pass in the same volume.

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(100));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- out_analog_level = apm_->gain_control()->stream_analog_level();

- }

- // Ensure the AGC is still able to reach the maximum.

- EXPECT_EQ(255, out_analog_level);

-// Verifies that despite volume slider quantization, the AGC can continue to

-// increase its volume.

-TEST_F(ApmTest, QuantizedVolumeDoesNotGetStuck) {

- for (size_t i = 0; i < arraysize(kSampleRates); ++i) {

- RunQuantizedVolumeDoesNotGetStuckTest(kSampleRates[i]);

- }

-void ApmTest::RunManualVolumeChangeIsPossibleTest(int sample_rate) {

- Init(sample_rate, sample_rate, sample_rate, 2, 2, 2, false);

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_mode(GainControl::kAdaptiveAnalog));

- EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));

- int out_analog_level = 100;

- for (int i = 0; i < 1000; ++i) {

- ReadFrameWithRewind(near_file_, frame_);

- // Ensure the audio is at a low level, so the AGC will try to increase it.

- ScaleFrame(frame_, 0.25);

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(out_analog_level));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- out_analog_level = apm_->gain_control()->stream_analog_level();

- }

- // Ensure the volume was raised.

- EXPECT_GT(out_analog_level, 100);

- int highest_level_reached = out_analog_level;

- // Simulate a user manual volume change.

- out_analog_level = 100;

- for (int i = 0; i < 300; ++i) {

- ReadFrameWithRewind(near_file_, frame_);

- ScaleFrame(frame_, 0.25);

- EXPECT_EQ(apm_->kNoError,

- apm_->gain_control()->set_stream_analog_level(out_analog_level));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- out_analog_level = apm_->gain_control()->stream_analog_level();

- // Check that AGC respected the manually adjusted volume.

- EXPECT_LT(out_analog_level, highest_level_reached);

- }

- // Check that the volume was still raised.

- EXPECT_GT(out_analog_level, 100);

-TEST_F(ApmTest, ManualVolumeChangeIsPossible) {

- for (size_t i = 0; i < arraysize(kSampleRates); ++i) {

- RunManualVolumeChangeIsPossibleTest(kSampleRates[i]);

- }

-#if !defined(WEBRTC_ANDROID) && !defined(WEBRTC_IOS)

-TEST_F(ApmTest, AgcOnlyAdaptsWhenTargetSignalIsPresent) {

- const int kSampleRateHz = 16000;

- const size_t kSamplesPerChannel =

- static_cast<size_t>(AudioProcessing::kChunkSizeMs * kSampleRateHz / 1000);

- const size_t kNumInputChannels = 2;

- const size_t kNumOutputChannels = 1;

- const size_t kNumChunks = 700;

- const float kScaleFactor = 0.25f;

- Config config;

- std::vector<webrtc::Point> geometry;

- geometry.push_back(webrtc::Point(0.f, 0.f, 0.f));

- geometry.push_back(webrtc::Point(0.05f, 0.f, 0.f));

- config.Set<Beamforming>(new Beamforming(true, geometry));

- testing::NiceMock<MockNonlinearBeamformer>* beamformer =

- new testing::NiceMock<MockNonlinearBeamformer>(geometry);

- std::unique_ptr<AudioProcessing> apm(

- AudioProcessing::Create(config, beamformer));

- EXPECT_EQ(kNoErr, apm->gain_control()->Enable(true));

- ChannelBuffer<float> src_buf(kSamplesPerChannel, kNumInputChannels);

- ChannelBuffer<float> dest_buf(kSamplesPerChannel, kNumOutputChannels);

- const size_t max_length = kSamplesPerChannel * std::max(kNumInputChannels,

- kNumOutputChannels);

- std::unique_ptr<int16_t[]> int_data(new int16_t[max_length]);

- std::unique_ptr<float[]> float_data(new float[max_length]);

- std::string filename = ResourceFilePath("far", kSampleRateHz);

- FILE* far_file = fopen(filename.c_str(), "rb");

- ASSERT_TRUE(far_file != NULL) << "Could not open file " << filename << "\n";

- const int kDefaultVolume = apm->gain_control()->stream_analog_level();

- const int kDefaultCompressionGain =

- apm->gain_control()->compression_gain_db();

- bool is_target = false;

- EXPECT_CALL(*beamformer, is_target_present())

- .WillRepeatedly(testing::ReturnPointee(&is_target));

- for (size_t i = 0; i < kNumChunks; ++i) {

- ASSERT_TRUE(ReadChunk(far_file,

- int_data.get(),

- float_data.get(),

- &src_buf));

- for (size_t j = 0; j < kNumInputChannels; ++j) {

- for (size_t k = 0; k < kSamplesPerChannel; ++k) {

- src_buf.channels()[j][k] *= kScaleFactor;

- }

- EXPECT_EQ(kNoErr,

- apm->ProcessStream(src_buf.channels(),

- src_buf.num_frames(),

- kSampleRateHz,

- LayoutFromChannels(src_buf.num_channels()),

- kSampleRateHz,

- LayoutFromChannels(dest_buf.num_channels()),

- dest_buf.channels()));

- }

- EXPECT_EQ(kDefaultVolume,

- apm->gain_control()->stream_analog_level());

- EXPECT_EQ(kDefaultCompressionGain,

- apm->gain_control()->compression_gain_db());

- rewind(far_file);

- is_target = true;

- for (size_t i = 0; i < kNumChunks; ++i) {

- ASSERT_TRUE(ReadChunk(far_file,

- int_data.get(),

- float_data.get(),

- &src_buf));

- for (size_t j = 0; j < kNumInputChannels; ++j) {

- for (size_t k = 0; k < kSamplesPerChannel; ++k) {

- src_buf.channels()[j][k] *= kScaleFactor;

- }

- EXPECT_EQ(kNoErr,

- apm->ProcessStream(src_buf.channels(),

- src_buf.num_frames(),

- kSampleRateHz,

- LayoutFromChannels(src_buf.num_channels()),

- kSampleRateHz,

- LayoutFromChannels(dest_buf.num_channels()),

- dest_buf.channels()));

- }

- EXPECT_LT(kDefaultVolume,

- apm->gain_control()->stream_analog_level());

- EXPECT_LT(kDefaultCompressionGain,

- apm->gain_control()->compression_gain_db());

- ASSERT_EQ(0, fclose(far_file));

-#endif

-TEST_F(ApmTest, NoiseSuppression) {

- // Test valid suppression levels.

- NoiseSuppression::Level level[] = {

- NoiseSuppression::kLow,

- NoiseSuppression::kModerate,

- NoiseSuppression::kHigh,

- NoiseSuppression::kVeryHigh

- };

- for (size_t i = 0; i < arraysize(level); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->noise_suppression()->set_level(level[i]));

- EXPECT_EQ(level[i], apm_->noise_suppression()->level());

- }

- // Turn NS on/off

- EXPECT_EQ(apm_->kNoError, apm_->noise_suppression()->Enable(true));

- EXPECT_TRUE(apm_->noise_suppression()->is_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->noise_suppression()->Enable(false));

- EXPECT_FALSE(apm_->noise_suppression()->is_enabled());

-TEST_F(ApmTest, HighPassFilter) {

- // Turn HP filter on/off

- EXPECT_EQ(apm_->kNoError, apm_->high_pass_filter()->Enable(true));

- EXPECT_TRUE(apm_->high_pass_filter()->is_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->high_pass_filter()->Enable(false));

- EXPECT_FALSE(apm_->high_pass_filter()->is_enabled());

-TEST_F(ApmTest, LevelEstimator) {

- // Turn level estimator on/off

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(false));

- EXPECT_FALSE(apm_->level_estimator()->is_enabled());

- EXPECT_EQ(apm_->kNotEnabledError, apm_->level_estimator()->RMS());

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(true));

- EXPECT_TRUE(apm_->level_estimator()->is_enabled());

- // Run this test in wideband; in super-wb, the splitting filter distorts the

- // audio enough to cause deviation from the expectation for small values.

- frame_->samples_per_channel_ = 160;

- frame_->num_channels_ = 2;

- frame_->sample_rate_hz_ = 16000;

- // Min value if no frames have been processed.

- EXPECT_EQ(127, apm_->level_estimator()->RMS());

- // Min value on zero frames.

- SetFrameTo(frame_, 0);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(127, apm_->level_estimator()->RMS());

- // Try a few RMS values.

- // (These also test that the value resets after retrieving it.)

- SetFrameTo(frame_, 32767);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(0, apm_->level_estimator()->RMS());

- SetFrameTo(frame_, 30000);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(1, apm_->level_estimator()->RMS());

- SetFrameTo(frame_, 10000);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(10, apm_->level_estimator()->RMS());

- SetFrameTo(frame_, 10);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(70, apm_->level_estimator()->RMS());

- // Verify reset after enable/disable.

- SetFrameTo(frame_, 32767);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(false));

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(true));

- SetFrameTo(frame_, 1);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(90, apm_->level_estimator()->RMS());

- // Verify reset after initialize.

- SetFrameTo(frame_, 32767);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(apm_->kNoError, apm_->Initialize());

- SetFrameTo(frame_, 1);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(90, apm_->level_estimator()->RMS());

-TEST_F(ApmTest, VoiceDetection) {

- // Test external VAD

- EXPECT_EQ(apm_->kNoError,

- apm_->voice_detection()->set_stream_has_voice(true));

- EXPECT_TRUE(apm_->voice_detection()->stream_has_voice());

- EXPECT_EQ(apm_->kNoError,

- apm_->voice_detection()->set_stream_has_voice(false));

- EXPECT_FALSE(apm_->voice_detection()->stream_has_voice());

- // Test valid likelihoods

- VoiceDetection::Likelihood likelihood[] = {

- VoiceDetection::kVeryLowLikelihood,

- VoiceDetection::kLowLikelihood,

- VoiceDetection::kModerateLikelihood,

- VoiceDetection::kHighLikelihood

- };

- for (size_t i = 0; i < arraysize(likelihood); i++) {

- EXPECT_EQ(apm_->kNoError,

- apm_->voice_detection()->set_likelihood(likelihood[i]));

- EXPECT_EQ(likelihood[i], apm_->voice_detection()->likelihood());

- }

- /* TODO(bjornv): Enable once VAD supports other frame lengths than 10 ms

- // Test invalid frame sizes

- EXPECT_EQ(apm_->kBadParameterError,

- apm_->voice_detection()->set_frame_size_ms(12));

- // Test valid frame sizes

- for (int i = 10; i <= 30; i += 10) {

- EXPECT_EQ(apm_->kNoError,

- apm_->voice_detection()->set_frame_size_ms(i));

- EXPECT_EQ(i, apm_->voice_detection()->frame_size_ms());

- }

- */

- // Turn VAD on/off

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(true));

- EXPECT_TRUE(apm_->voice_detection()->is_enabled());

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(false));

- EXPECT_FALSE(apm_->voice_detection()->is_enabled());

- // Test that AudioFrame activity is maintained when VAD is disabled.

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(false));

- AudioFrame::VADActivity activity[] = {

- AudioFrame::kVadActive,

- AudioFrame::kVadPassive,

- AudioFrame::kVadUnknown

- };

- for (size_t i = 0; i < arraysize(activity); i++) {

- frame_->vad_activity_ = activity[i];

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(activity[i], frame_->vad_activity_);

- }

- // Test that AudioFrame activity is set when VAD is enabled.

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(true));

- frame_->vad_activity_ = AudioFrame::kVadUnknown;

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_NE(AudioFrame::kVadUnknown, frame_->vad_activity_);

- // TODO(bjornv): Add tests for streamed voice; stream_has_voice()

-TEST_F(ApmTest, AllProcessingDisabledByDefault) {

- EXPECT_FALSE(apm_->echo_cancellation()->is_enabled());

- EXPECT_FALSE(apm_->echo_control_mobile()->is_enabled());

- EXPECT_FALSE(apm_->gain_control()->is_enabled());

- EXPECT_FALSE(apm_->high_pass_filter()->is_enabled());

- EXPECT_FALSE(apm_->level_estimator()->is_enabled());

- EXPECT_FALSE(apm_->noise_suppression()->is_enabled());

- EXPECT_FALSE(apm_->voice_detection()->is_enabled());

-TEST_F(ApmTest, NoProcessingWhenAllComponentsDisabled) {

- for (size_t i = 0; i < arraysize(kSampleRates); i++) {

- Init(kSampleRates[i], kSampleRates[i], kSampleRates[i], 2, 2, 2, false);

- SetFrameTo(frame_, 1000, 2000);

- AudioFrame frame_copy;

- frame_copy.CopyFrom(*frame_);

- for (int j = 0; j < 1000; j++) {

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- }

-TEST_F(ApmTest, NoProcessingWhenAllComponentsDisabledFloat) {

- // Test that ProcessStream copies input to output even with no processing.

- const size_t kSamples = 80;

- const int sample_rate = 8000;

- const float src[kSamples] = {

- -1.0f, 0.0f, 1.0f

- };

- float dest[kSamples] = {};

- auto src_channels = &src[0];

- auto dest_channels = &dest[0];

- apm_.reset(AudioProcessing::Create());

- EXPECT_NOERR(apm_->ProcessStream(

- &src_channels, kSamples, sample_rate, LayoutFromChannels(1),

- sample_rate, LayoutFromChannels(1), &dest_channels));

- for (size_t i = 0; i < kSamples; ++i) {

- EXPECT_EQ(src[i], dest[i]);

- }

- // Same for ProcessReverseStream.

- float rev_dest[kSamples] = {};

- auto rev_dest_channels = &rev_dest[0];

- StreamConfig input_stream = {sample_rate, 1};

- StreamConfig output_stream = {sample_rate, 1};

- EXPECT_NOERR(apm_->ProcessReverseStream(&src_channels, input_stream,

- output_stream, &rev_dest_channels));

- for (size_t i = 0; i < kSamples; ++i) {

- EXPECT_EQ(src[i], rev_dest[i]);

- }

-TEST_F(ApmTest, IdenticalInputChannelsResultInIdenticalOutputChannels) {

- EnableAllComponents();

- for (size_t i = 0; i < arraysize(kProcessSampleRates); i++) {

- Init(kProcessSampleRates[i],

- kProcessSampleRates[i],

- 2,

- false);

- int analog_level = 127;

- ASSERT_EQ(0, feof(far_file_));

- ASSERT_EQ(0, feof(near_file_));

- while (ReadFrame(far_file_, revframe_) && ReadFrame(near_file_, frame_)) {

- CopyLeftToRightChannel(revframe_->data_, revframe_->samples_per_channel_);

- ASSERT_EQ(kNoErr, apm_->ProcessReverseStream(revframe_));

- CopyLeftToRightChannel(frame_->data_, frame_->samples_per_channel_);

- frame_->vad_activity_ = AudioFrame::kVadUnknown;

- ASSERT_EQ(kNoErr, apm_->set_stream_delay_ms(0));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- ASSERT_EQ(kNoErr,

- apm_->gain_control()->set_stream_analog_level(analog_level));

- ASSERT_EQ(kNoErr, apm_->ProcessStream(frame_));

- analog_level = apm_->gain_control()->stream_analog_level();

- VerifyChannelsAreEqual(frame_->data_, frame_->samples_per_channel_);

- }

- rewind(far_file_);

- rewind(near_file_);

- }

-TEST_F(ApmTest, SplittingFilter) {

- // Verify the filter is not active through undistorted audio when:

- // 1. No components are enabled...

- SetFrameTo(frame_, 1000);

- AudioFrame frame_copy;

- frame_copy.CopyFrom(*frame_);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- // 2. Only the level estimator is enabled...

- SetFrameTo(frame_, 1000);

- frame_copy.CopyFrom(*frame_);

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(true));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(false));

- // 3. Only VAD is enabled...

- SetFrameTo(frame_, 1000);

- frame_copy.CopyFrom(*frame_);

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(true));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(false));

- // 4. Both VAD and the level estimator are enabled...

- SetFrameTo(frame_, 1000);

- frame_copy.CopyFrom(*frame_);

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(true));

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(true));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(false));

- EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(false));

- // 5. Not using super-wb.

- frame_->samples_per_channel_ = 160;

- frame_->num_channels_ = 2;

- frame_->sample_rate_hz_ = 16000;

- // Enable AEC, which would require the filter in super-wb. We rely on the

- // first few frames of data being unaffected by the AEC.

- // TODO(andrew): This test, and the one below, rely rather tenuously on the

- // behavior of the AEC. Think of something more robust.

- EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));

- // Make sure we have extended filter enabled. This makes sure nothing is

- // touched until we have a farend frame.

- Config config;

- config.Set<ExtendedFilter>(new ExtendedFilter(true));

- apm_->SetExtraOptions(config);

- SetFrameTo(frame_, 1000);

- frame_copy.CopyFrom(*frame_);

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));

- // Check the test is valid. We should have distortion from the filter

- // when AEC is enabled (which won't affect the audio).

- frame_->samples_per_channel_ = 320;

- frame_->num_channels_ = 2;

- frame_->sample_rate_hz_ = 32000;

- SetFrameTo(frame_, 1000);

- frame_copy.CopyFrom(*frame_);

- EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));

- 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) {

- 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));

- 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) {

- memcpy(revfloat_cb_->channels()[i],

- msg.channel(i).data(),

- msg.channel(i).size());

- }

- } else {

- memcpy(revframe_->data_, msg.data().data(), msg.data().size());

- if (format == kFloatFormat) {

- // We're using an int16 input file; convert to float.

- ConvertToFloat(*revframe_, revfloat_cb_.get());

- }

- AnalyzeReverseStreamChooser(format);

- } else if (event_msg.type() == audioproc::Event::STREAM) {

- const audioproc::Stream msg = event_msg.stream();

- // ProcessStream could have changed this for the output frame.

- frame_->num_channels_ = apm_->num_input_channels();

- EXPECT_NOERR(apm_->gain_control()->set_stream_analog_level(msg.level()));

- EXPECT_NOERR(apm_->set_stream_delay_ms(msg.delay()));

- apm_->echo_cancellation()->set_stream_drift_samples(msg.drift());

- if (msg.has_keypress()) {

- apm_->set_stream_key_pressed(msg.keypress());

- } else {

- apm_->set_stream_key_pressed(true);

- }

- if (msg.input_channel_size() > 0) {

- ASSERT_EQ(frame_->num_channels_,

- static_cast<size_t>(msg.input_channel_size()));

- for (int i = 0; i < msg.input_channel_size(); ++i) {

- memcpy(float_cb_->channels()[i],

- msg.input_channel(i).data(),

- msg.input_channel(i).size());

- }

- } else {

- memcpy(frame_->data_, msg.input_data().data(), msg.input_data().size());

- if (format == kFloatFormat) {

- // We're using an int16 input file; convert to float.

- ConvertToFloat(*frame_, float_cb_.get());

- }

- ProcessStreamChooser(format);

- }

- EXPECT_NOERR(apm_->StopDebugRecording());

- fclose(in_file);

-void ApmTest::VerifyDebugDumpTest(Format format) {

- const std::string in_filename = test::ResourcePath("ref03", "aecdump");

- std::string format_string;

- switch (format) {

- case kIntFormat:

- format_string = "_int";

- break;

- case kFloatFormat:

- format_string = "_float";

- break;

- }

- const std::string ref_filename = test::TempFilename(

- test::OutputPath(), std::string("ref") + format_string + "_aecdump");

- const std::string out_filename = test::TempFilename(

- test::OutputPath(), std::string("out") + format_string + "_aecdump");

- const std::string limited_filename = test::TempFilename(

- test::OutputPath(), std::string("limited") + format_string + "_aecdump");

- const size_t logging_limit_bytes = 100000;

- // We expect at least this many bytes in the created logfile.

- const size_t logging_expected_bytes = 95000;

- EnableAllComponents();

- ProcessDebugDump(in_filename, ref_filename, format, -1);

- ProcessDebugDump(ref_filename, out_filename, format, -1);

- ProcessDebugDump(ref_filename, limited_filename, format, logging_limit_bytes);

- FILE* ref_file = fopen(ref_filename.c_str(), "rb");

- FILE* out_file = fopen(out_filename.c_str(), "rb");

- FILE* limited_file = fopen(limited_filename.c_str(), "rb");

- ASSERT_TRUE(ref_file != NULL);

- ASSERT_TRUE(out_file != NULL);

- ASSERT_TRUE(limited_file != NULL);

- std::unique_ptr<uint8_t[]> ref_bytes;

- std::unique_ptr<uint8_t[]> out_bytes;

- std::unique_ptr<uint8_t[]> limited_bytes;

- size_t ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);

- size_t out_size = ReadMessageBytesFromFile(out_file, &out_bytes);

- size_t limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);

- size_t bytes_read = 0;

- size_t bytes_read_limited = 0;

- while (ref_size > 0 && out_size > 0) {

- bytes_read += ref_size;

- bytes_read_limited += limited_size;

- EXPECT_EQ(ref_size, out_size);

- EXPECT_GE(ref_size, limited_size);

- EXPECT_EQ(0, memcmp(ref_bytes.get(), out_bytes.get(), ref_size));

- EXPECT_EQ(0, memcmp(ref_bytes.get(), limited_bytes.get(), limited_size));

- ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);

- out_size = ReadMessageBytesFromFile(out_file, &out_bytes);

- limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);

- }

- EXPECT_GT(bytes_read, 0u);

- EXPECT_GT(bytes_read_limited, logging_expected_bytes);

- EXPECT_LE(bytes_read_limited, logging_limit_bytes);

- EXPECT_NE(0, feof(ref_file));

- EXPECT_NE(0, feof(out_file));

- EXPECT_NE(0, feof(limited_file));

- ASSERT_EQ(0, fclose(ref_file));

- ASSERT_EQ(0, fclose(out_file));

- ASSERT_EQ(0, fclose(limited_file));

- remove(ref_filename.c_str());

- remove(out_filename.c_str());

- remove(limited_filename.c_str());

-TEST_F(ApmTest, VerifyDebugDumpInt) {

- VerifyDebugDumpTest(kIntFormat);

-TEST_F(ApmTest, VerifyDebugDumpFloat) {

- VerifyDebugDumpTest(kFloatFormat);

-#endif

-// TODO(andrew): expand test to verify output.

-TEST_F(ApmTest, DebugDump) {

- 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_->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));

- const std::string filename =

- test::TempFilename(test::OutputPath(), "debug_aec");

- 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_->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));

- ASSERT_EQ(0, remove(filename.c_str()));

-#else

- EXPECT_EQ(apm_->kUnsupportedFunctionError,

- apm_->StartDebugRecording(fid, -1));

- EXPECT_EQ(apm_->kUnsupportedFunctionError, apm_->StopDebugRecording());

- ASSERT_EQ(0, fclose(fid));

-#endif // WEBRTC_AUDIOPROC_DEBUG_DUMP

-TEST_F(ApmTest, FloatAndIntInterfacesGiveSimilarResults) {

- audioproc::OutputData ref_data;

- OpenFileAndReadMessage(ref_filename_, &ref_data);

- Config config;

- config.Set<ExperimentalAgc>(new ExperimentalAgc(false));

- std::unique_ptr<AudioProcessing> fapm(AudioProcessing::Create(config));

- EnableAllComponents();

- EnableAllAPComponents(fapm.get());

- for (int i = 0; i < ref_data.test_size(); i++) {

- printf("Running test %d of %d...\n", i + 1, ref_data.test_size());

- audioproc::Test* test = ref_data.mutable_test(i);

- // TODO(ajm): Restore downmixing test cases.

- if (test->num_input_channels() != test->num_output_channels())

- continue;

- const size_t num_render_channels =

- static_cast<size_t>(test->num_reverse_channels());

- const size_t num_input_channels =

- static_cast<size_t>(test->num_input_channels());

- const size_t num_output_channels =

- static_cast<size_t>(test->num_output_channels());

- const size_t samples_per_channel = static_cast<size_t>(

- test->sample_rate() * AudioProcessing::kChunkSizeMs / 1000);

- Init(test->sample_rate(), test->sample_rate(), test->sample_rate(),

- num_input_channels, num_output_channels, num_render_channels, true);

- Init(fapm.get());

- ChannelBuffer<int16_t> output_cb(samples_per_channel, num_input_channels);

- ChannelBuffer<int16_t> output_int16(samples_per_channel,

- num_input_channels);

- int analog_level = 127;

- size_t num_bad_chunks = 0;

- while (ReadFrame(far_file_, revframe_, revfloat_cb_.get()) &&

- ReadFrame(near_file_, frame_, float_cb_.get())) {

- frame_->vad_activity_ = AudioFrame::kVadUnknown;

- EXPECT_NOERR(apm_->ProcessReverseStream(revframe_));

- EXPECT_NOERR(fapm->AnalyzeReverseStream(

- revfloat_cb_->channels(),

- samples_per_channel,

- test->sample_rate(),

- LayoutFromChannels(num_render_channels)));

- EXPECT_NOERR(apm_->set_stream_delay_ms(0));

- EXPECT_NOERR(fapm->set_stream_delay_ms(0));

- apm_->echo_cancellation()->set_stream_drift_samples(0);

- fapm->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_NOERR(apm_->gain_control()->set_stream_analog_level(analog_level));

- EXPECT_NOERR(fapm->gain_control()->set_stream_analog_level(analog_level));

- EXPECT_NOERR(apm_->ProcessStream(frame_));

- Deinterleave(frame_->data_, samples_per_channel, num_output_channels,

- output_int16.channels());

- EXPECT_NOERR(fapm->ProcessStream(

- float_cb_->channels(),

- samples_per_channel,

- test->sample_rate(),

- LayoutFromChannels(num_input_channels),

- test->sample_rate(),

- LayoutFromChannels(num_output_channels),

- float_cb_->channels()));

- for (size_t j = 0; j < num_output_channels; ++j) {

- FloatToS16(float_cb_->channels()[j],

- samples_per_channel,

- output_cb.channels()[j]);

- float variance = 0;

- float snr = ComputeSNR(output_int16.channels()[j],

- output_cb.channels()[j],

- samples_per_channel, &variance);

- const float kVarianceThreshold = 20;

- const float kSNRThreshold = 20;

- // Skip frames with low energy.

- if (sqrt(variance) > kVarianceThreshold && snr < kSNRThreshold) {

- ++num_bad_chunks;

- }

- analog_level = fapm->gain_control()->stream_analog_level();

- EXPECT_EQ(apm_->gain_control()->stream_analog_level(),

- fapm->gain_control()->stream_analog_level());

- EXPECT_EQ(apm_->echo_cancellation()->stream_has_echo(),

- fapm->echo_cancellation()->stream_has_echo());

- EXPECT_NEAR(apm_->noise_suppression()->speech_probability(),

- fapm->noise_suppression()->speech_probability(),

- 0.01);

- // Reset in case of downmixing.

- frame_->num_channels_ = static_cast<size_t>(test->num_input_channels());

- }

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

- const size_t kMaxNumBadChunks = 0;

-#elif defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)

- // There are a few chunks in the fixed-point profile that give low SNR.

- // Listening confirmed the difference is acceptable.

- const size_t kMaxNumBadChunks = 60;

-#endif

- EXPECT_LE(num_bad_chunks, kMaxNumBadChunks);

- rewind(far_file_);

- rewind(near_file_);

- }

-// TODO(andrew): Add a test to process a few frames with different combinations

-// of enabled components.

-TEST_F(ApmTest, Process) {

- GOOGLE_PROTOBUF_VERIFY_VERSION;

- audioproc::OutputData ref_data;

- if (!write_ref_data) {

- OpenFileAndReadMessage(ref_filename_, &ref_data);

- } else {

- // Write the desired tests to the protobuf reference file.

- for (size_t i = 0; i < arraysize(kChannels); i++) {

- for (size_t j = 0; j < arraysize(kChannels); j++) {

- for (size_t l = 0; l < arraysize(kProcessSampleRates); l++) {

- audioproc::Test* test = ref_data.add_test();

- test->set_num_reverse_channels(kChannels[i]);

- test->set_num_input_channels(kChannels[j]);

- test->set_num_output_channels(kChannels[j]);

- test->set_sample_rate(kProcessSampleRates[l]);

- test->set_use_aec_extended_filter(false);

- }

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

- // To test the extended filter mode.

- audioproc::Test* test = ref_data.add_test();

- test->set_num_reverse_channels(2);

- test->set_num_input_channels(2);

- test->set_num_output_channels(2);

- test->set_sample_rate(AudioProcessing::kSampleRate32kHz);

- test->set_use_aec_extended_filter(true);

-#endif

- }

- for (int i = 0; i < ref_data.test_size(); i++) {

- printf("Running test %d of %d...\n", i + 1, ref_data.test_size());

- audioproc::Test* test = ref_data.mutable_test(i);

- // TODO(ajm): We no longer allow different input and output channels. Skip

- // these tests for now, but they should be removed from the set.

- if (test->num_input_channels() != test->num_output_channels())

- continue;

- Config config;

- config.Set<ExperimentalAgc>(new ExperimentalAgc(false));

- config.Set<ExtendedFilter>(

- new ExtendedFilter(test->use_aec_extended_filter()));

- apm_.reset(AudioProcessing::Create(config));

- EnableAllComponents();

- Init(test->sample_rate(),

- test->sample_rate(),

- static_cast<size_t>(test->num_input_channels()),

- static_cast<size_t>(test->num_output_channels()),

- static_cast<size_t>(test->num_reverse_channels()),

- true);

- int frame_count = 0;

- int has_echo_count = 0;

- int has_voice_count = 0;

- int is_saturated_count = 0;

- int analog_level = 127;

- int analog_level_average = 0;

- int max_output_average = 0;

- float ns_speech_prob_average = 0.0f;

- while (ReadFrame(far_file_, revframe_) && ReadFrame(near_file_, frame_)) {

- EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));

- frame_->vad_activity_ = AudioFrame::kVadUnknown;

- 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(analog_level));

- EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));

- // Ensure the frame was downmixed properly.

- EXPECT_EQ(static_cast<size_t>(test->num_output_channels()),

- frame_->num_channels_);

- max_output_average += MaxAudioFrame(*frame_);

- if (apm_->echo_cancellation()->stream_has_echo()) {

- has_echo_count++;

- }

- analog_level = apm_->gain_control()->stream_analog_level();

- analog_level_average += analog_level;

- if (apm_->gain_control()->stream_is_saturated()) {

- is_saturated_count++;

- }

- if (apm_->voice_detection()->stream_has_voice()) {

- has_voice_count++;

- EXPECT_EQ(AudioFrame::kVadActive, frame_->vad_activity_);

- } else {

- EXPECT_EQ(AudioFrame::kVadPassive, frame_->vad_activity_);

- }

- ns_speech_prob_average += apm_->noise_suppression()->speech_probability();

- size_t frame_size = frame_->samples_per_channel_ * frame_->num_channels_;

- size_t write_count = fwrite(frame_->data_,

- sizeof(int16_t),

- frame_size,

- out_file_);

- ASSERT_EQ(frame_size, write_count);

- // Reset in case of downmixing.

- frame_->num_channels_ = static_cast<size_t>(test->num_input_channels());

- frame_count++;

- }

- max_output_average /= frame_count;

- analog_level_average /= frame_count;

- ns_speech_prob_average /= frame_count;

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

- EchoCancellation::Metrics echo_metrics;

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->GetMetrics(&echo_metrics));

- int median = 0;

- int std = 0;

- float fraction_poor_delays = 0;

- EXPECT_EQ(apm_->kNoError,

- apm_->echo_cancellation()->GetDelayMetrics(

- &median, &std, &fraction_poor_delays));

- int rms_level = apm_->level_estimator()->RMS();

- EXPECT_LE(0, rms_level);

- EXPECT_GE(127, rms_level);

-#endif

- if (!write_ref_data) {

- const int kIntNear = 1;

- // When running the test on a N7 we get a {2, 6} difference of

- // |has_voice_count| and |max_output_average| is up to 18 higher.

- // All numbers being consistently higher on N7 compare to ref_data.

- // TODO(bjornv): If we start getting more of these offsets on Android we

- // should consider a different approach. Either using one slack for all,

- // or generate a separate android reference.

-#if defined(WEBRTC_ANDROID)

- const int kHasVoiceCountOffset = 3;

- const int kHasVoiceCountNear = 3;

- const int kMaxOutputAverageOffset = 9;

- const int kMaxOutputAverageNear = 9;

-#else

- const int kHasVoiceCountOffset = 0;

- const int kHasVoiceCountNear = kIntNear;

- const int kMaxOutputAverageOffset = 0;

- const int kMaxOutputAverageNear = kIntNear;

-#endif

- EXPECT_NEAR(test->has_echo_count(), has_echo_count, kIntNear);

- EXPECT_NEAR(test->has_voice_count(),

- has_voice_count - kHasVoiceCountOffset,

- kHasVoiceCountNear);

- EXPECT_NEAR(test->is_saturated_count(), is_saturated_count, kIntNear);

- EXPECT_NEAR(test->analog_level_average(), analog_level_average, kIntNear);

- EXPECT_NEAR(test->max_output_average(),

- max_output_average - kMaxOutputAverageOffset,

- kMaxOutputAverageNear);

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

- audioproc::Test::EchoMetrics reference = test->echo_metrics();

- TestStats(echo_metrics.residual_echo_return_loss,

- reference.residual_echo_return_loss());

- TestStats(echo_metrics.echo_return_loss,

- reference.echo_return_loss());

- TestStats(echo_metrics.echo_return_loss_enhancement,

- reference.echo_return_loss_enhancement());

- TestStats(echo_metrics.a_nlp,

- reference.a_nlp());

- const double kFloatNear = 0.0005;

- audioproc::Test::DelayMetrics reference_delay = test->delay_metrics();

- EXPECT_NEAR(reference_delay.median(), median, kIntNear);

- EXPECT_NEAR(reference_delay.std(), std, kIntNear);

- EXPECT_NEAR(reference_delay.fraction_poor_delays(), fraction_poor_delays,

- kFloatNear);

- EXPECT_NEAR(test->rms_level(), rms_level, kIntNear);

- EXPECT_NEAR(test->ns_speech_probability_average(),

- ns_speech_prob_average,

- kFloatNear);

-#endif

- } else {

- test->set_has_echo_count(has_echo_count);

- test->set_has_voice_count(has_voice_count);

- test->set_is_saturated_count(is_saturated_count);

- test->set_analog_level_average(analog_level_average);

- test->set_max_output_average(max_output_average);

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

- audioproc::Test::EchoMetrics* message = test->mutable_echo_metrics();

- WriteStatsMessage(echo_metrics.residual_echo_return_loss,

- message->mutable_residual_echo_return_loss());

- WriteStatsMessage(echo_metrics.echo_return_loss,

- message->mutable_echo_return_loss());

- WriteStatsMessage(echo_metrics.echo_return_loss_enhancement,

- message->mutable_echo_return_loss_enhancement());

- WriteStatsMessage(echo_metrics.a_nlp,

- message->mutable_a_nlp());

- audioproc::Test::DelayMetrics* message_delay =

- test->mutable_delay_metrics();

- message_delay->set_median(median);

- message_delay->set_std(std);

- message_delay->set_fraction_poor_delays(fraction_poor_delays);

- test->set_rms_level(rms_level);

- EXPECT_LE(0.0f, ns_speech_prob_average);

- EXPECT_GE(1.0f, ns_speech_prob_average);

- test->set_ns_speech_probability_average(ns_speech_prob_average);

-#endif

- }

- rewind(far_file_);

- rewind(near_file_);

- }

- if (write_ref_data) {

- OpenFileAndWriteMessage(ref_filename_, ref_data);

- }

-TEST_F(ApmTest, NoErrorsWithKeyboardChannel) {

- struct ChannelFormat {

- AudioProcessing::ChannelLayout in_layout;

- AudioProcessing::ChannelLayout out_layout;

- };

- ChannelFormat cf[] = {

- {AudioProcessing::kMonoAndKeyboard, AudioProcessing::kMono},

- {AudioProcessing::kStereoAndKeyboard, AudioProcessing::kMono},

- {AudioProcessing::kStereoAndKeyboard, AudioProcessing::kStereo},

- };

- std::unique_ptr<AudioProcessing> ap(AudioProcessing::Create());

- // Enable one component just to ensure some processing takes place.

- ap->noise_suppression()->Enable(true);

- for (size_t i = 0; i < arraysize(cf); ++i) {

- const int in_rate = 44100;

- const int out_rate = 48000;

- ChannelBuffer<float> in_cb(SamplesFromRate(in_rate),

- TotalChannelsFromLayout(cf[i].in_layout));

- ChannelBuffer<float> out_cb(SamplesFromRate(out_rate),

- ChannelsFromLayout(cf[i].out_layout));

- // Run over a few chunks.

- for (int j = 0; j < 10; ++j) {

- EXPECT_NOERR(ap->ProcessStream(

- in_cb.channels(),

- in_cb.num_frames(),

- in_rate,

- cf[i].in_layout,

- out_rate,

- cf[i].out_layout,

- out_cb.channels()));

- }

-// Compares the reference and test arrays over a region around the expected

-// delay. Finds the highest SNR in that region and adds the variance and squared

-// error results to the supplied accumulators.

-void UpdateBestSNR(const float* ref,

- const float* test,

- size_t length,

- int expected_delay,

- double* variance_acc,

- double* sq_error_acc) {

- double best_snr = std::numeric_limits<double>::min();

- double best_variance = 0;

- double best_sq_error = 0;

- // Search over a region of eight samples around the expected delay.

- for (int delay = std::max(expected_delay - 4, 0); delay <= expected_delay + 4;

- ++delay) {

- double sq_error = 0;

- double variance = 0;

- for (size_t i = 0; i < length - delay; ++i) {

- double error = test[i + delay] - ref[i];

- sq_error += error * error;

- variance += ref[i] * ref[i];

- }

- if (sq_error == 0) {

- *variance_acc += variance;

- return;

- }

- double snr = variance / sq_error;

- if (snr > best_snr) {

- best_snr = snr;

- best_variance = variance;

- best_sq_error = sq_error;

- }

- *variance_acc += best_variance;

- *sq_error_acc += best_sq_error;

-// Used to test a multitude of sample rate and channel combinations. It works

-// by first producing a set of reference files (in SetUpTestCase) that are

-// assumed to be correct, as the used parameters are verified by other tests

-// in this collection. Primarily the reference files are all produced at

-// "native" rates which do not involve any resampling.

-// Each test pass produces an output file with a particular format. The output

-// is matched against the reference file closest to its internal processing

-// format. If necessary the output is resampled back to its process format.

-// Due to the resampling distortion, we don't expect identical results, but

-// enforce SNR thresholds which vary depending on the format. 0 is a special

-// case SNR which corresponds to inf, or zero error.

-typedef std::tr1::tuple<int, int, int, int, double, double>

- AudioProcessingTestData;

-class AudioProcessingTest

- : public testing::TestWithParam<AudioProcessingTestData> {

- public:

- AudioProcessingTest()

- : input_rate_(std::tr1::get<0>(GetParam())),

- output_rate_(std::tr1::get<1>(GetParam())),

- reverse_input_rate_(std::tr1::get<2>(GetParam())),

- reverse_output_rate_(std::tr1::get<3>(GetParam())),

- expected_snr_(std::tr1::get<4>(GetParam())),

- expected_reverse_snr_(std::tr1::get<5>(GetParam())) {}

- virtual ~AudioProcessingTest() {}

- static void SetUpTestCase() {

- // Create all needed output reference files.

- const int kNativeRates[] = {8000, 16000, 32000, 48000};

- const size_t kNumChannels[] = {1, 2};

- for (size_t i = 0; i < arraysize(kNativeRates); ++i) {

- for (size_t j = 0; j < arraysize(kNumChannels); ++j) {

- for (size_t k = 0; k < arraysize(kNumChannels); ++k) {

- // The reference files always have matching input and output channels.

- ProcessFormat(kNativeRates[i], kNativeRates[i], kNativeRates[i],

- kNativeRates[i], kNumChannels[j], kNumChannels[j],

- kNumChannels[k], kNumChannels[k], "ref");

- }

- static void TearDownTestCase() {

- ClearTempFiles();

- }

- // Runs a process pass on files with the given parameters and dumps the output

- // to a file specified with |output_file_prefix|. Both forward and reverse

- // output streams are dumped.

- static void ProcessFormat(int input_rate,

- int output_rate,

- int reverse_input_rate,

- int reverse_output_rate,

- size_t num_input_channels,

- size_t num_output_channels,

- size_t num_reverse_input_channels,

- size_t num_reverse_output_channels,

- std::string output_file_prefix) {

- Config config;

- config.Set<ExperimentalAgc>(new ExperimentalAgc(false));

- std::unique_ptr<AudioProcessing> ap(AudioProcessing::Create(config));

- EnableAllAPComponents(ap.get());

- ProcessingConfig processing_config = {

- {{input_rate, num_input_channels},

- {output_rate, num_output_channels},

- {reverse_input_rate, num_reverse_input_channels},

- {reverse_output_rate, num_reverse_output_channels}}};

- ap->Initialize(processing_config);

- FILE* far_file =

- fopen(ResourceFilePath("far", reverse_input_rate).c_str(), "rb");

- FILE* near_file = fopen(ResourceFilePath("near", input_rate).c_str(), "rb");

- FILE* out_file =

- fopen(OutputFilePath(output_file_prefix, input_rate, output_rate,

- reverse_input_rate, reverse_output_rate,

- num_input_channels, num_output_channels,

- num_reverse_input_channels,

- num_reverse_output_channels, kForward).c_str(),

- "wb");

- FILE* rev_out_file =

- fopen(OutputFilePath(output_file_prefix, input_rate, output_rate,

- reverse_input_rate, reverse_output_rate,

- num_input_channels, num_output_channels,

- num_reverse_input_channels,

- num_reverse_output_channels, kReverse).c_str(),

- "wb");

- ASSERT_TRUE(far_file != NULL);

- ASSERT_TRUE(near_file != NULL);

- ASSERT_TRUE(out_file != NULL);

- ASSERT_TRUE(rev_out_file != NULL);

- ChannelBuffer<float> fwd_cb(SamplesFromRate(input_rate),

- num_input_channels);

- ChannelBuffer<float> rev_cb(SamplesFromRate(reverse_input_rate),

- num_reverse_input_channels);

- ChannelBuffer<float> out_cb(SamplesFromRate(output_rate),

- num_output_channels);

- ChannelBuffer<float> rev_out_cb(SamplesFromRate(reverse_output_rate),

- num_reverse_output_channels);

- // Temporary buffers.

- const int max_length =

- 2 * std::max(std::max(out_cb.num_frames(), rev_out_cb.num_frames()),

- std::max(fwd_cb.num_frames(), rev_cb.num_frames()));

- std::unique_ptr<float[]> float_data(new float[max_length]);

- std::unique_ptr<int16_t[]> int_data(new int16_t[max_length]);

- int analog_level = 127;

- while (ReadChunk(far_file, int_data.get(), float_data.get(), &rev_cb) &&

- ReadChunk(near_file, int_data.get(), float_data.get(), &fwd_cb)) {

- EXPECT_NOERR(ap->ProcessReverseStream(

- rev_cb.channels(), processing_config.reverse_input_stream(),

- processing_config.reverse_output_stream(), rev_out_cb.channels()));

- EXPECT_NOERR(ap->set_stream_delay_ms(0));

- ap->echo_cancellation()->set_stream_drift_samples(0);

- EXPECT_NOERR(ap->gain_control()->set_stream_analog_level(analog_level));

- EXPECT_NOERR(ap->ProcessStream(

- fwd_cb.channels(),

- fwd_cb.num_frames(),

- input_rate,

- LayoutFromChannels(num_input_channels),

- output_rate,

- LayoutFromChannels(num_output_channels),

- out_cb.channels()));

- // Dump forward output to file.

- Interleave(out_cb.channels(), out_cb.num_frames(), out_cb.num_channels(),

- float_data.get());

- size_t out_length = out_cb.num_channels() * out_cb.num_frames();

- ASSERT_EQ(out_length,

- fwrite(float_data.get(), sizeof(float_data[0]),

- out_length, out_file));

- // Dump reverse output to file.

- Interleave(rev_out_cb.channels(), rev_out_cb.num_frames(),

- rev_out_cb.num_channels(), float_data.get());

- size_t rev_out_length =

- rev_out_cb.num_channels() * rev_out_cb.num_frames();

- ASSERT_EQ(rev_out_length,

- fwrite(float_data.get(), sizeof(float_data[0]), rev_out_length,

- rev_out_file));

- analog_level = ap->gain_control()->stream_analog_level();

- }

- fclose(far_file);

- fclose(near_file);

- fclose(out_file);

- fclose(rev_out_file);

- }

- protected:

- int input_rate_;

- int output_rate_;

- int reverse_input_rate_;

- int reverse_output_rate_;

- double expected_snr_;

- double expected_reverse_snr_;

-};

-TEST_P(AudioProcessingTest, Formats) {

- struct ChannelFormat {

- int num_input;

- int num_output;

- int num_reverse_input;

- int num_reverse_output;

- };

- ChannelFormat cf[] = {

- {1, 1, 1, 1},

- {1, 1, 2, 1},

- {2, 1, 1, 1},

- {2, 1, 2, 1},

- {2, 2, 1, 1},

- {2, 2, 2, 2},

- };

- for (size_t i = 0; i < arraysize(cf); ++i) {

- ProcessFormat(input_rate_, output_rate_, reverse_input_rate_,

- reverse_output_rate_, cf[i].num_input, cf[i].num_output,

- cf[i].num_reverse_input, cf[i].num_reverse_output, "out");

- // Verify output for both directions.

- std::vector<StreamDirection> stream_directions;

- stream_directions.push_back(kForward);

- stream_directions.push_back(kReverse);

- for (StreamDirection file_direction : stream_directions) {

- const int in_rate = file_direction ? reverse_input_rate_ : input_rate_;

- const int out_rate = file_direction ? reverse_output_rate_ : output_rate_;

- const int out_num =

- file_direction ? cf[i].num_reverse_output : cf[i].num_output;

- const double expected_snr =

- file_direction ? expected_reverse_snr_ : expected_snr_;

- const int min_ref_rate = std::min(in_rate, out_rate);

- int ref_rate;

- if (min_ref_rate > 32000) {

- ref_rate = 48000;

- } else if (min_ref_rate > 16000) {

- ref_rate = 32000;

- } else if (min_ref_rate > 8000) {

- ref_rate = 16000;

- } else {

- ref_rate = 8000;

- }

-#ifdef WEBRTC_ARCH_ARM_FAMILY

- if (file_direction == kForward) {

- ref_rate = std::min(ref_rate, 32000);

- }

-#endif

- FILE* out_file = fopen(

- OutputFilePath("out", input_rate_, output_rate_, reverse_input_rate_,

- reverse_output_rate_, cf[i].num_input,

- cf[i].num_output, cf[i].num_reverse_input,

- cf[i].num_reverse_output, file_direction).c_str(),

- "rb");

- // The reference files always have matching input and output channels.

- FILE* ref_file = fopen(

- OutputFilePath("ref", ref_rate, ref_rate, ref_rate, ref_rate,

- cf[i].num_output, cf[i].num_output,

- cf[i].num_reverse_output, cf[i].num_reverse_output,

- file_direction).c_str(),

- "rb");

- ASSERT_TRUE(out_file != NULL);

- ASSERT_TRUE(ref_file != NULL);

- const size_t ref_length = SamplesFromRate(ref_rate) * out_num;

- const size_t out_length = SamplesFromRate(out_rate) * out_num;

- // Data from the reference file.

- std::unique_ptr<float[]> ref_data(new float[ref_length]);

- // Data from the output file.

- std::unique_ptr<float[]> out_data(new float[out_length]);

- // Data from the resampled output, in case the reference and output rates

- // don't match.

- std::unique_ptr<float[]> cmp_data(new float[ref_length]);

- PushResampler<float> resampler;

- resampler.InitializeIfNeeded(out_rate, ref_rate, out_num);

- // Compute the resampling delay of the output relative to the reference,

- // to find the region over which we should search for the best SNR.

- float expected_delay_sec = 0;

- if (in_rate != ref_rate) {

- // Input resampling delay.

- expected_delay_sec +=

- PushSincResampler::AlgorithmicDelaySeconds(in_rate);

- }

- if (out_rate != ref_rate) {

- // Output resampling delay.

- expected_delay_sec +=

- PushSincResampler::AlgorithmicDelaySeconds(ref_rate);

- // Delay of converting the output back to its processing rate for

- // testing.

- expected_delay_sec +=

- PushSincResampler::AlgorithmicDelaySeconds(out_rate);

- }

- int expected_delay =

- floor(expected_delay_sec * ref_rate + 0.5f) * out_num;

- double variance = 0;

- double sq_error = 0;

- while (fread(out_data.get(), sizeof(out_data[0]), out_length, out_file) &&

- fread(ref_data.get(), sizeof(ref_data[0]), ref_length, ref_file)) {

- float* out_ptr = out_data.get();

- if (out_rate != ref_rate) {

- // Resample the output back to its internal processing rate if

- // necssary.

- ASSERT_EQ(ref_length,

- static_cast<size_t>(resampler.Resample(

- out_ptr, out_length, cmp_data.get(), ref_length)));

- out_ptr = cmp_data.get();

- }

- // Update the |sq_error| and |variance| accumulators with the highest

- // SNR of reference vs output.

- UpdateBestSNR(ref_data.get(), out_ptr, ref_length, expected_delay,

- &variance, &sq_error);

- }

- std::cout << "(" << input_rate_ << ", " << output_rate_ << ", "

- << reverse_input_rate_ << ", " << reverse_output_rate_ << ", "

- << cf[i].num_input << ", " << cf[i].num_output << ", "

- << cf[i].num_reverse_input << ", " << cf[i].num_reverse_output

- << ", " << file_direction << "): ";

- if (sq_error > 0) {

- double snr = 10 * log10(variance / sq_error);

- EXPECT_GE(snr, expected_snr);

- EXPECT_NE(0, expected_snr);

- std::cout << "SNR=" << snr << " dB" << std::endl;

- } else {

- std::cout << "SNR=inf dB" << std::endl;

- }

- fclose(out_file);

- fclose(ref_file);

- }

-#if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)

-INSTANTIATE_TEST_CASE_P(

- CommonFormats,

- AudioProcessingTest,

- testing::Values(std::tr1::make_tuple(48000, 48000, 48000, 48000, 0, 0),

- std::tr1::make_tuple(48000, 48000, 32000, 48000, 35, 30),

- std::tr1::make_tuple(48000, 48000, 16000, 48000, 35, 20),

- std::tr1::make_tuple(48000, 44100, 48000, 44100, 20, 20),

- std::tr1::make_tuple(48000, 44100, 32000, 44100, 20, 15),

- std::tr1::make_tuple(48000, 44100, 16000, 44100, 20, 15),

- std::tr1::make_tuple(48000, 32000, 48000, 32000, 30, 35),

- std::tr1::make_tuple(48000, 32000, 32000, 32000, 30, 0),

- std::tr1::make_tuple(48000, 32000, 16000, 32000, 30, 20),

- std::tr1::make_tuple(48000, 16000, 48000, 16000, 25, 20),

- std::tr1::make_tuple(48000, 16000, 32000, 16000, 25, 20),

- std::tr1::make_tuple(48000, 16000, 16000, 16000, 25, 0),

- std::tr1::make_tuple(44100, 48000, 48000, 48000, 30, 0),

- std::tr1::make_tuple(44100, 48000, 32000, 48000, 30, 30),

- std::tr1::make_tuple(44100, 48000, 16000, 48000, 30, 20),

- std::tr1::make_tuple(44100, 44100, 48000, 44100, 20, 20),

- std::tr1::make_tuple(44100, 44100, 32000, 44100, 20, 15),

- std::tr1::make_tuple(44100, 44100, 16000, 44100, 20, 15),

- std::tr1::make_tuple(44100, 32000, 48000, 32000, 30, 35),

- std::tr1::make_tuple(44100, 32000, 32000, 32000, 30, 0),

- std::tr1::make_tuple(44100, 32000, 16000, 32000, 30, 20),

- std::tr1::make_tuple(44100, 16000, 48000, 16000, 25, 20),

- std::tr1::make_tuple(44100, 16000, 32000, 16000, 25, 20),

- std::tr1::make_tuple(44100, 16000, 16000, 16000, 25, 0),

- std::tr1::make_tuple(32000, 48000, 48000, 48000, 30, 0),

- std::tr1::make_tuple(32000, 48000, 32000, 48000, 35, 30),

- std::tr1::make_tuple(32000, 48000, 16000, 48000, 30, 20),

- std::tr1::make_tuple(32000, 44100, 48000, 44100, 20, 20),

- std::tr1::make_tuple(32000, 44100, 32000, 44100, 20, 15),

- std::tr1::make_tuple(32000, 44100, 16000, 44100, 20, 15),

- std::tr1::make_tuple(32000, 32000, 48000, 32000, 40, 35),

- std::tr1::make_tuple(32000, 32000, 32000, 32000, 0, 0),

- std::tr1::make_tuple(32000, 32000, 16000, 32000, 40, 20),

- std::tr1::make_tuple(32000, 16000, 48000, 16000, 25, 20),

- std::tr1::make_tuple(32000, 16000, 32000, 16000, 25, 20),

- std::tr1::make_tuple(32000, 16000, 16000, 16000, 25, 0),

- std::tr1::make_tuple(16000, 48000, 48000, 48000, 25, 0),

- std::tr1::make_tuple(16000, 48000, 32000, 48000, 25, 30),

- std::tr1::make_tuple(16000, 48000, 16000, 48000, 25, 20),

- std::tr1::make_tuple(16000, 44100, 48000, 44100, 15, 20),

- std::tr1::make_tuple(16000, 44100, 32000, 44100, 15, 15),

- std::tr1::make_tuple(16000, 44100, 16000, 44100, 15, 15),

- std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),

- std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),

- std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),

- std::tr1::make_tuple(16000, 16000, 48000, 16000, 40, 20),

- std::tr1::make_tuple(16000, 16000, 32000, 16000, 40, 20),

- std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));

-#elif defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)

-INSTANTIATE_TEST_CASE_P(

- CommonFormats,

- AudioProcessingTest,

- testing::Values(std::tr1::make_tuple(48000, 48000, 48000, 48000, 20, 0),

- std::tr1::make_tuple(48000, 48000, 32000, 48000, 20, 30),

- std::tr1::make_tuple(48000, 48000, 16000, 48000, 20, 20),

- std::tr1::make_tuple(48000, 44100, 48000, 44100, 15, 20),

- std::tr1::make_tuple(48000, 44100, 32000, 44100, 15, 15),

- std::tr1::make_tuple(48000, 44100, 16000, 44100, 15, 15),

- std::tr1::make_tuple(48000, 32000, 48000, 32000, 20, 35),

- std::tr1::make_tuple(48000, 32000, 32000, 32000, 20, 0),

- std::tr1::make_tuple(48000, 32000, 16000, 32000, 20, 20),

- std::tr1::make_tuple(48000, 16000, 48000, 16000, 20, 20),

- std::tr1::make_tuple(48000, 16000, 32000, 16000, 20, 20),

- std::tr1::make_tuple(48000, 16000, 16000, 16000, 20, 0),

- std::tr1::make_tuple(44100, 48000, 48000, 48000, 15, 0),

- std::tr1::make_tuple(44100, 48000, 32000, 48000, 15, 30),

- std::tr1::make_tuple(44100, 48000, 16000, 48000, 15, 20),

- std::tr1::make_tuple(44100, 44100, 48000, 44100, 15, 20),

- std::tr1::make_tuple(44100, 44100, 32000, 44100, 15, 15),

- std::tr1::make_tuple(44100, 44100, 16000, 44100, 15, 15),

- std::tr1::make_tuple(44100, 32000, 48000, 32000, 20, 35),

- std::tr1::make_tuple(44100, 32000, 32000, 32000, 20, 0),

- std::tr1::make_tuple(44100, 32000, 16000, 32000, 20, 20),

- std::tr1::make_tuple(44100, 16000, 48000, 16000, 20, 20),

- std::tr1::make_tuple(44100, 16000, 32000, 16000, 20, 20),

- std::tr1::make_tuple(44100, 16000, 16000, 16000, 20, 0),

- std::tr1::make_tuple(32000, 48000, 48000, 48000, 35, 0),

- std::tr1::make_tuple(32000, 48000, 32000, 48000, 65, 30),

- std::tr1::make_tuple(32000, 48000, 16000, 48000, 40, 20),

- std::tr1::make_tuple(32000, 44100, 48000, 44100, 20, 20),

- std::tr1::make_tuple(32000, 44100, 32000, 44100, 20, 15),

- std::tr1::make_tuple(32000, 44100, 16000, 44100, 20, 15),

- std::tr1::make_tuple(32000, 32000, 48000, 32000, 35, 35),

- std::tr1::make_tuple(32000, 32000, 32000, 32000, 0, 0),

- std::tr1::make_tuple(32000, 32000, 16000, 32000, 40, 20),

- std::tr1::make_tuple(32000, 16000, 48000, 16000, 20, 20),

- std::tr1::make_tuple(32000, 16000, 32000, 16000, 20, 20),

- std::tr1::make_tuple(32000, 16000, 16000, 16000, 20, 0),

- std::tr1::make_tuple(16000, 48000, 48000, 48000, 25, 0),

- std::tr1::make_tuple(16000, 48000, 32000, 48000, 25, 30),

- std::tr1::make_tuple(16000, 48000, 16000, 48000, 25, 20),

- std::tr1::make_tuple(16000, 44100, 48000, 44100, 15, 20),

- std::tr1::make_tuple(16000, 44100, 32000, 44100, 15, 15),

- std::tr1::make_tuple(16000, 44100, 16000, 44100, 15, 15),

- std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),

- std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),

- std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),

- std::tr1::make_tuple(16000, 16000, 48000, 16000, 35, 20),

- std::tr1::make_tuple(16000, 16000, 32000, 16000, 35, 20),

- std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));

-#endif

-} // namespace

-} // namespace webrtc

« no previous file with comments | « webrtc/modules/audio_processing/audio_processing_unittest.cc ('k') | webrtc/modules/modules.gyp » ('j') | no next file with comments »