a6f54fd726
Review URL: http://webrtc-codereview.appspot.com/38002 git-svn-id: http://webrtc.googlecode.com/svn/trunk@90 4adac7df-926f-26a2-2b94-8c16560cd09d
1007 lines
36 KiB
C++
1007 lines
36 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "unit_test.h"
|
|
|
|
#include "event_wrapper.h"
|
|
#include "module_common_types.h"
|
|
#include "thread_wrapper.h"
|
|
#include "trace.h"
|
|
#include "signal_processing_library.h"
|
|
|
|
#include "audio_processing.h"
|
|
|
|
namespace webrtc {
|
|
namespace {
|
|
|
|
// If false, this will write out a new statistics file.
|
|
// For usual testing we normally want to read the file.
|
|
const bool kReadStatFile = true;
|
|
|
|
struct ThreadData {
|
|
ThreadData(int thread_num_, AudioProcessing* ap_)
|
|
: thread_num(thread_num_),
|
|
error(false),
|
|
ap(ap_) {}
|
|
int thread_num;
|
|
bool error;
|
|
AudioProcessing* ap;
|
|
};
|
|
|
|
// Don't use GTest here; non-thread-safe on Windows (as of 1.5.0).
|
|
bool DeadlockProc(void* thread_object) {
|
|
ThreadData* thread_data = static_cast<ThreadData*>(thread_object);
|
|
AudioProcessing* ap = thread_data->ap;
|
|
int err = ap->kNoError;
|
|
|
|
AudioFrame primary_frame;
|
|
AudioFrame reverse_frame;
|
|
primary_frame._payloadDataLengthInSamples = 320;
|
|
primary_frame._audioChannel = 2;
|
|
primary_frame._frequencyInHz = 32000;
|
|
reverse_frame._payloadDataLengthInSamples = 320;
|
|
reverse_frame._audioChannel = 2;
|
|
reverse_frame._frequencyInHz = 32000;
|
|
|
|
ap->echo_cancellation()->Enable(true);
|
|
ap->gain_control()->Enable(true);
|
|
ap->high_pass_filter()->Enable(true);
|
|
ap->level_estimator()->Enable(true);
|
|
ap->noise_suppression()->Enable(true);
|
|
ap->voice_detection()->Enable(true);
|
|
|
|
if (thread_data->thread_num % 2 == 0) {
|
|
err = ap->AnalyzeReverseStream(&reverse_frame);
|
|
if (err != ap->kNoError) {
|
|
printf("Error in AnalyzeReverseStream(): %d\n", err);
|
|
thread_data->error = true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (thread_data->thread_num % 2 == 1) {
|
|
ap->set_stream_delay_ms(0);
|
|
ap->echo_cancellation()->set_stream_drift_samples(0);
|
|
ap->gain_control()->set_stream_analog_level(0);
|
|
err = ap->ProcessStream(&primary_frame);
|
|
if (err == ap->kStreamParameterNotSetError) {
|
|
printf("Expected kStreamParameterNotSetError in ProcessStream(): %d\n",
|
|
err);
|
|
} else if (err != ap->kNoError) {
|
|
printf("Error in ProcessStream(): %d\n", err);
|
|
thread_data->error = true;
|
|
return false;
|
|
}
|
|
ap->gain_control()->stream_analog_level();
|
|
}
|
|
|
|
EventWrapper* event = EventWrapper::Create();
|
|
event->Wait(1);
|
|
delete event;
|
|
event = NULL;
|
|
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
class ApmEnvironment : public ::testing::Environment {
|
|
public:
|
|
virtual void SetUp() {
|
|
Trace::CreateTrace();
|
|
ASSERT_EQ(0, Trace::SetTraceFile("ApmTrace.txt"));
|
|
}
|
|
|
|
virtual void TearDown() {
|
|
Trace::ReturnTrace();
|
|
}
|
|
};
|
|
|
|
ApmTest::ApmTest()
|
|
: apm_(NULL),
|
|
far_file_(NULL),
|
|
near_file_(NULL),
|
|
stat_file_(NULL),
|
|
frame_(NULL),
|
|
reverse_frame_(NULL) {}
|
|
|
|
void ApmTest::SetUp() {
|
|
apm_ = AudioProcessing::Create(0);
|
|
ASSERT_TRUE(apm_ != NULL);
|
|
|
|
frame_ = new AudioFrame();
|
|
reverse_frame_ = new AudioFrame();
|
|
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_sample_rate_hz(32000));
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_num_channels(2, 2));
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_num_reverse_channels(2));
|
|
|
|
frame_->_payloadDataLengthInSamples = 320;
|
|
frame_->_audioChannel = 2;
|
|
frame_->_frequencyInHz = 32000;
|
|
reverse_frame_->_payloadDataLengthInSamples = 320;
|
|
reverse_frame_->_audioChannel = 2;
|
|
reverse_frame_->_frequencyInHz = 32000;
|
|
|
|
far_file_ = fopen("aecFar.pcm", "rb");
|
|
ASSERT_TRUE(far_file_ != NULL) << "Cannot read source file aecFar.pcm\n";
|
|
near_file_ = fopen("aecNear.pcm", "rb");
|
|
ASSERT_TRUE(near_file_ != NULL) << "Cannot read source file aecNear.pcm\n";
|
|
|
|
if (kReadStatFile) {
|
|
stat_file_ = fopen("statData.dat", "rb");
|
|
ASSERT_TRUE(stat_file_ != NULL) <<
|
|
"Cannot write to source file statData.dat\n";
|
|
}
|
|
}
|
|
|
|
void ApmTest::TearDown() {
|
|
if (frame_) {
|
|
delete frame_;
|
|
}
|
|
frame_ = NULL;
|
|
|
|
if (reverse_frame_) {
|
|
delete reverse_frame_;
|
|
}
|
|
reverse_frame_ = 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 (stat_file_) {
|
|
ASSERT_EQ(0, fclose(stat_file_));
|
|
}
|
|
stat_file_ = NULL;
|
|
|
|
if (apm_ != NULL) {
|
|
AudioProcessing::Destroy(apm_);
|
|
}
|
|
apm_ = NULL;
|
|
}
|
|
|
|
/*TEST_F(ApmTest, Deadlock) {
|
|
const int num_threads = 16;
|
|
std::vector<ThreadWrapper*> threads(num_threads);
|
|
std::vector<ThreadData*> thread_data(num_threads);
|
|
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_sample_rate_hz(32000));
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_num_channels(2, 2));
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_num_reverse_channels(2));
|
|
|
|
for (int i = 0; i < num_threads; i++) {
|
|
thread_data[i] = new ThreadData(i, apm_);
|
|
threads[i] = ThreadWrapper::CreateThread(DeadlockProc,
|
|
thread_data[i],
|
|
kNormalPriority,
|
|
0);
|
|
ASSERT_TRUE(threads[i] != NULL);
|
|
unsigned int thread_id = 0;
|
|
threads[i]->Start(thread_id);
|
|
}
|
|
|
|
EventWrapper* event = EventWrapper::Create();
|
|
ASSERT_EQ(kEventTimeout, event->Wait(5000));
|
|
delete event;
|
|
event = NULL;
|
|
|
|
for (int i = 0; i < num_threads; i++) {
|
|
// This will return false if the thread has deadlocked.
|
|
ASSERT_TRUE(threads[i]->Stop());
|
|
ASSERT_FALSE(thread_data[i]->error);
|
|
delete threads[i];
|
|
threads[i] = NULL;
|
|
delete thread_data[i];
|
|
thread_data[i] = NULL;
|
|
}
|
|
}*/
|
|
|
|
TEST_F(ApmTest, StreamParameters) {
|
|
// No errors when the components are disabled.
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->ProcessStream(frame_));
|
|
|
|
// Missing agc level
|
|
EXPECT_EQ(apm_->kNoError, apm_->Initialize());
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
|
|
EXPECT_EQ(apm_->kStreamParameterNotSetError,
|
|
apm_->ProcessStream(frame_));
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->set_stream_drift_samples(0));
|
|
EXPECT_EQ(apm_->kStreamParameterNotSetError,
|
|
apm_->ProcessStream(frame_));
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(false));
|
|
|
|
// Missing delay
|
|
EXPECT_EQ(apm_->kNoError, apm_->Initialize());
|
|
EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));
|
|
EXPECT_EQ(apm_->kStreamParameterNotSetError,
|
|
apm_->ProcessStream(frame_));
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->set_stream_drift_samples(0));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->gain_control()->set_stream_analog_level(127));
|
|
EXPECT_EQ(apm_->kStreamParameterNotSetError,
|
|
apm_->ProcessStream(frame_));
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(false));
|
|
|
|
// Missing drift
|
|
EXPECT_EQ(apm_->kNoError, apm_->Initialize());
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->enable_drift_compensation(true));
|
|
EXPECT_EQ(apm_->kStreamParameterNotSetError,
|
|
apm_->ProcessStream(frame_));
|
|
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,
|
|
apm_->ProcessStream(frame_));
|
|
|
|
// No stream parameters
|
|
EXPECT_EQ(apm_->kNoError, apm_->Initialize());
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->AnalyzeReverseStream(reverse_frame_));
|
|
EXPECT_EQ(apm_->kStreamParameterNotSetError,
|
|
apm_->ProcessStream(frame_));
|
|
|
|
// All there
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
|
|
EXPECT_EQ(apm_->kNoError, apm_->Initialize());
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
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_));
|
|
}
|
|
|
|
TEST_F(ApmTest, Channels) {
|
|
// Testing number of invalid channels
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_channels(0, 1));
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_channels(1, 0));
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_channels(3, 1));
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_channels(1, 3));
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_reverse_channels(0));
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_reverse_channels(3));
|
|
// Testing number of valid channels
|
|
for (int i = 1; i < 3; i++) {
|
|
for (int j = 1; j < 3; j++) {
|
|
if (j > i) {
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_num_channels(i, j));
|
|
} else {
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_num_channels(i, j));
|
|
EXPECT_EQ(j, apm_->num_output_channels());
|
|
}
|
|
}
|
|
EXPECT_EQ(i, apm_->num_input_channels());
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_num_reverse_channels(i));
|
|
EXPECT_EQ(i, apm_->num_reverse_channels());
|
|
}
|
|
}
|
|
|
|
TEST_F(ApmTest, SampleRates) {
|
|
// Testing invalid sample rates
|
|
EXPECT_EQ(apm_->kBadParameterError, apm_->set_sample_rate_hz(10000));
|
|
// Testing valid sample rates
|
|
int fs[] = {8000, 16000, 32000};
|
|
for (size_t i = 0; i < sizeof(fs) / sizeof(*fs); i++) {
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_sample_rate_hz(fs[i]));
|
|
EXPECT_EQ(fs[i], apm_->sample_rate_hz());
|
|
}
|
|
}
|
|
|
|
TEST_F(ApmTest, Process) {
|
|
if (!kReadStatFile) {
|
|
stat_file_ = fopen("statData.dat", "wb");
|
|
ASSERT_TRUE(stat_file_ != NULL)
|
|
<< "Cannot write to source file statData.dat\n";
|
|
}
|
|
|
|
AudioFrame render_audio;
|
|
AudioFrame capture_audio;
|
|
|
|
render_audio._payloadDataLengthInSamples = 320;
|
|
render_audio._audioChannel = 2;
|
|
render_audio._frequencyInHz = 32000;
|
|
capture_audio._payloadDataLengthInSamples = 320;
|
|
capture_audio._audioChannel = 2;
|
|
capture_audio._frequencyInHz = 32000;
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->enable_drift_compensation(true));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->enable_metrics(true));
|
|
EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->gain_control()->set_mode(GainControl::kAdaptiveAnalog));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->gain_control()->set_analog_level_limits(0, 255));
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->high_pass_filter()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kUnsupportedComponentError,
|
|
apm_->level_estimator()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->noise_suppression()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->voice_detection()->Enable(true));
|
|
|
|
LevelEstimator::Metrics far_metrics;
|
|
LevelEstimator::Metrics near_metrics;
|
|
EchoCancellation::Metrics echo_metrics;
|
|
for (int i = 0; i < 100; i++) {
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->AnalyzeReverseStream(&render_audio));
|
|
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
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(&capture_audio));
|
|
|
|
apm_->echo_cancellation()->stream_has_echo();
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->GetMetrics(&echo_metrics));
|
|
|
|
apm_->gain_control()->stream_analog_level();
|
|
apm_->gain_control()->stream_is_saturated();
|
|
|
|
EXPECT_EQ(apm_->kUnsupportedComponentError,
|
|
apm_->level_estimator()->GetMetrics(&near_metrics,
|
|
&far_metrics));
|
|
|
|
apm_->voice_detection()->stream_has_voice();
|
|
}
|
|
|
|
// Test with real audio
|
|
// Loop through all possible combinations
|
|
// (# reverse channels, # channels, sample rates)
|
|
int rev_ch[] = {1, 2};
|
|
int ch[] = {1, 2};
|
|
int fs[] = {8000, 16000, 32000};
|
|
size_t rev_ch_size = sizeof(rev_ch) / sizeof(*rev_ch);
|
|
size_t ch_size = sizeof(ch) / sizeof(*ch);
|
|
size_t fs_size = sizeof(fs) / sizeof(*fs);
|
|
if (kReadStatFile) {
|
|
fread(&rev_ch_size, sizeof(rev_ch_size), 1, stat_file_);
|
|
fread(rev_ch, sizeof(int), rev_ch_size, stat_file_);
|
|
fread(&ch_size, sizeof(ch_size), 1, stat_file_);
|
|
fread(ch, sizeof(int), ch_size, stat_file_);
|
|
fread(&fs_size, sizeof(fs_size), 1, stat_file_);
|
|
fread(fs, sizeof(int), fs_size, stat_file_);
|
|
} else {
|
|
fwrite(&rev_ch_size, sizeof(int), 1, stat_file_);
|
|
fwrite(rev_ch, sizeof(int), rev_ch_size, stat_file_);
|
|
fwrite(&ch_size, sizeof(int), 1, stat_file_);
|
|
fwrite(ch, sizeof(int), ch_size, stat_file_);
|
|
fwrite(&fs_size, sizeof(int), 1, stat_file_);
|
|
fwrite(fs, sizeof(int), fs_size, stat_file_);
|
|
}
|
|
int test_count = 0;
|
|
for (size_t i_rev_ch = 0; i_rev_ch < rev_ch_size; i_rev_ch++) {
|
|
for (size_t i_ch = 0; i_ch < ch_size; i_ch++) {
|
|
for (size_t i_fs = 0; i_fs < fs_size; i_fs++) {
|
|
render_audio._payloadDataLengthInSamples = fs[i_fs] / 100;
|
|
render_audio._audioChannel = rev_ch[i_rev_ch];
|
|
render_audio._frequencyInHz = fs[i_fs];
|
|
capture_audio._payloadDataLengthInSamples = fs[i_fs] / 100;
|
|
capture_audio._audioChannel = ch[i_ch];
|
|
capture_audio._frequencyInHz = fs[i_fs];
|
|
|
|
EXPECT_EQ(apm_->kNoError, apm_->Initialize());
|
|
ASSERT_EQ(apm_->kNoError, apm_->set_sample_rate_hz(fs[i_fs]));
|
|
ASSERT_EQ(apm_->kNoError,
|
|
apm_->set_num_channels(capture_audio._audioChannel,
|
|
capture_audio._audioChannel));
|
|
ASSERT_EQ(apm_->kNoError,
|
|
apm_->set_num_reverse_channels(render_audio._audioChannel));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->enable_drift_compensation(false));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->enable_metrics(true));
|
|
EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->gain_control()->set_mode(GainControl::kAdaptiveAnalog));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->gain_control()->set_analog_level_limits(0, 255));
|
|
EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->high_pass_filter()->Enable(true));
|
|
|
|
//EXPECT_EQ(apm_->kNoError,
|
|
// apm_->level_estimator()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->noise_suppression()->Enable(true));
|
|
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->voice_detection()->Enable(true));
|
|
bool runningFiles = true;
|
|
int echo_count = 0;
|
|
int vad_count = 0;
|
|
int sat_count = 0;
|
|
int analog_level = 127;
|
|
int sat_gain = 2;
|
|
size_t read_count = 0;
|
|
WebRtc_Word16 tmpData[640];
|
|
int tmp_int;
|
|
|
|
int echo_count_ref_ = 0;
|
|
int vad_count_ref_ = 0;
|
|
int sat_count_ref_ = 0;
|
|
//LevelEstimator::Metrics far_metrics_ref_;
|
|
//LevelEstimator::Metrics near_metrics_ref_;
|
|
EchoCancellation::Metrics echo_metrics_ref_;
|
|
|
|
while (runningFiles) {
|
|
// Read far end frame
|
|
read_count = fread(tmpData,
|
|
sizeof(WebRtc_Word16),
|
|
render_audio._payloadDataLengthInSamples * 2,
|
|
far_file_);
|
|
if (read_count !=
|
|
static_cast<size_t>
|
|
(render_audio._payloadDataLengthInSamples * 2)) {
|
|
break; // This is expected.
|
|
}
|
|
if (render_audio._audioChannel == 1) {
|
|
for (int i = 0; i < render_audio._payloadDataLengthInSamples;
|
|
i++) {
|
|
tmp_int = (static_cast<int>(tmpData[i * 2]) +
|
|
static_cast<int>(tmpData[i * 2 + 1])) >> 1;
|
|
render_audio._payloadData[i] =
|
|
static_cast<WebRtc_Word16>(tmp_int);
|
|
}
|
|
} else {
|
|
memcpy(render_audio._payloadData,
|
|
&tmpData[0],
|
|
sizeof(WebRtc_Word16) * read_count);
|
|
}
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->AnalyzeReverseStream(&render_audio));
|
|
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->gain_control()->set_stream_analog_level(analog_level));
|
|
|
|
// Read near end frame
|
|
read_count = fread(tmpData,
|
|
sizeof(WebRtc_Word16),
|
|
capture_audio._payloadDataLengthInSamples * 2,
|
|
near_file_);
|
|
if (read_count !=
|
|
static_cast<size_t>
|
|
(capture_audio._payloadDataLengthInSamples * 2)) {
|
|
break; // This is expected.
|
|
}
|
|
if (capture_audio._audioChannel == 1) {
|
|
for (int i = 0;
|
|
i < capture_audio._payloadDataLengthInSamples; i++) {
|
|
tmp_int = (static_cast<int>(tmpData[i * 2]) +
|
|
static_cast<int>(tmpData[i * 2 + 1])) >> 1;
|
|
capture_audio._payloadData[i] =
|
|
static_cast<WebRtc_Word16>(tmp_int);
|
|
}
|
|
} else {
|
|
memcpy(capture_audio._payloadData,
|
|
&tmpData[0],
|
|
sizeof(WebRtc_Word16) * read_count);
|
|
}
|
|
WebRtc_Word32 tmpF = 0;
|
|
for (size_t i = 0; i < read_count; i++) {
|
|
tmpF = (WebRtc_Word32)capture_audio._payloadData[i] * sat_gain;
|
|
if (tmpF > WEBRTC_SPL_WORD16_MAX) {
|
|
capture_audio._payloadData[i] = WEBRTC_SPL_WORD16_MAX;
|
|
} else if (tmpF < WEBRTC_SPL_WORD16_MIN) {
|
|
capture_audio._payloadData[i] = WEBRTC_SPL_WORD16_MIN;
|
|
} else {
|
|
capture_audio._payloadData[i] = static_cast<WebRtc_Word16>(tmpF);
|
|
}
|
|
}
|
|
EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(&capture_audio));
|
|
|
|
if (apm_->echo_cancellation()->stream_has_echo()) {
|
|
echo_count++;
|
|
}
|
|
|
|
analog_level = apm_->gain_control()->stream_analog_level();
|
|
if (apm_->gain_control()->stream_is_saturated()) {
|
|
sat_count++;
|
|
sat_gain = 1;
|
|
}
|
|
if (apm_->voice_detection()->stream_has_voice()) {
|
|
vad_count++;
|
|
}
|
|
}
|
|
//<-- Statistics -->
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->GetMetrics(&echo_metrics));
|
|
//EXPECT_EQ(apm_->kNoError,
|
|
// apm_->level_estimator()->GetMetrics(&near_metrics,
|
|
|
|
// TODO(ajm): Perhaps we don't have to check every value? The average
|
|
// could be sufficient. Or, how about hashing the output?
|
|
if (kReadStatFile) {
|
|
// Read from statData
|
|
fread(&echo_count_ref_, 1, sizeof(echo_count), stat_file_);
|
|
EXPECT_EQ(echo_count_ref_, echo_count);
|
|
fread(&echo_metrics_ref_,
|
|
1,
|
|
sizeof(EchoCancellation::Metrics),
|
|
stat_file_);
|
|
EXPECT_EQ(echo_metrics_ref_.residual_echo_return_loss.instant,
|
|
echo_metrics.residual_echo_return_loss.instant);
|
|
EXPECT_EQ(echo_metrics_ref_.residual_echo_return_loss.average,
|
|
echo_metrics.residual_echo_return_loss.average);
|
|
EXPECT_EQ(echo_metrics_ref_.residual_echo_return_loss.maximum,
|
|
echo_metrics.residual_echo_return_loss.maximum);
|
|
EXPECT_EQ(echo_metrics_ref_.residual_echo_return_loss.minimum,
|
|
echo_metrics.residual_echo_return_loss.minimum);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss.instant,
|
|
echo_metrics.echo_return_loss.instant);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss.average,
|
|
echo_metrics.echo_return_loss.average);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss.maximum,
|
|
echo_metrics.echo_return_loss.maximum);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss.minimum,
|
|
echo_metrics.echo_return_loss.minimum);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss_enhancement.instant,
|
|
echo_metrics.echo_return_loss_enhancement.instant);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss_enhancement.average,
|
|
echo_metrics.echo_return_loss_enhancement.average);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss_enhancement.maximum,
|
|
echo_metrics.echo_return_loss_enhancement.maximum);
|
|
EXPECT_EQ(echo_metrics_ref_.echo_return_loss_enhancement.minimum,
|
|
echo_metrics.echo_return_loss_enhancement.minimum);
|
|
EXPECT_EQ(echo_metrics_ref_.a_nlp.instant,
|
|
echo_metrics.a_nlp.instant);
|
|
EXPECT_EQ(echo_metrics_ref_.a_nlp.average,
|
|
echo_metrics.a_nlp.average);
|
|
EXPECT_EQ(echo_metrics_ref_.a_nlp.maximum,
|
|
echo_metrics.a_nlp.maximum);
|
|
EXPECT_EQ(echo_metrics_ref_.a_nlp.minimum,
|
|
echo_metrics.a_nlp.minimum);
|
|
|
|
fread(&vad_count_ref_, 1, sizeof(vad_count), stat_file_);
|
|
EXPECT_EQ(vad_count_ref_, vad_count);
|
|
fread(&sat_count_ref_, 1, sizeof(sat_count), stat_file_);
|
|
EXPECT_EQ(sat_count_ref_, sat_count);
|
|
|
|
/*fread(&far_metrics_ref_,
|
|
1,
|
|
sizeof(LevelEstimator::Metrics),
|
|
stat_file_);
|
|
EXPECT_EQ(far_metrics_ref_.signal.instant,
|
|
far_metrics.signal.instant);
|
|
EXPECT_EQ(far_metrics_ref_.signal.average,
|
|
far_metrics.signal.average);
|
|
EXPECT_EQ(far_metrics_ref_.signal.maximum,
|
|
far_metrics.signal.maximum);
|
|
EXPECT_EQ(far_metrics_ref_.signal.minimum,
|
|
far_metrics.signal.minimum);
|
|
|
|
EXPECT_EQ(far_metrics_ref_.speech.instant,
|
|
far_metrics.speech.instant);
|
|
EXPECT_EQ(far_metrics_ref_.speech.average,
|
|
far_metrics.speech.average);
|
|
EXPECT_EQ(far_metrics_ref_.speech.maximum,
|
|
far_metrics.speech.maximum);
|
|
EXPECT_EQ(far_metrics_ref_.speech.minimum,
|
|
far_metrics.speech.minimum);
|
|
|
|
EXPECT_EQ(far_metrics_ref_.noise.instant,
|
|
far_metrics.noise.instant);
|
|
EXPECT_EQ(far_metrics_ref_.noise.average,
|
|
far_metrics.noise.average);
|
|
EXPECT_EQ(far_metrics_ref_.noise.maximum,
|
|
far_metrics.noise.maximum);
|
|
EXPECT_EQ(far_metrics_ref_.noise.minimum,
|
|
far_metrics.noise.minimum);
|
|
|
|
fread(&near_metrics_ref_,
|
|
1,
|
|
sizeof(LevelEstimator::Metrics),
|
|
stat_file_);
|
|
EXPECT_EQ(near_metrics_ref_.signal.instant,
|
|
near_metrics.signal.instant);
|
|
EXPECT_EQ(near_metrics_ref_.signal.average,
|
|
near_metrics.signal.average);
|
|
EXPECT_EQ(near_metrics_ref_.signal.maximum,
|
|
near_metrics.signal.maximum);
|
|
EXPECT_EQ(near_metrics_ref_.signal.minimum,
|
|
near_metrics.signal.minimum);
|
|
|
|
EXPECT_EQ(near_metrics_ref_.speech.instant,
|
|
near_metrics.speech.instant);
|
|
EXPECT_EQ(near_metrics_ref_.speech.average,
|
|
near_metrics.speech.average);
|
|
EXPECT_EQ(near_metrics_ref_.speech.maximum,
|
|
near_metrics.speech.maximum);
|
|
EXPECT_EQ(near_metrics_ref_.speech.minimum,
|
|
near_metrics.speech.minimum);
|
|
|
|
EXPECT_EQ(near_metrics_ref_.noise.instant,
|
|
near_metrics.noise.instant);
|
|
EXPECT_EQ(near_metrics_ref_.noise.average,
|
|
near_metrics.noise.average);
|
|
EXPECT_EQ(near_metrics_ref_.noise.maximum,
|
|
near_metrics.noise.maximum);
|
|
EXPECT_EQ(near_metrics_ref_.noise.minimum,
|
|
near_metrics.noise.minimum);*/
|
|
} else {
|
|
// Write to statData
|
|
fwrite(&echo_count, 1, sizeof(echo_count), stat_file_);
|
|
fwrite(&echo_metrics,
|
|
1,
|
|
sizeof(EchoCancellation::Metrics),
|
|
stat_file_);
|
|
fwrite(&vad_count, 1, sizeof(vad_count), stat_file_);
|
|
fwrite(&sat_count, 1, sizeof(sat_count), stat_file_);
|
|
//fwrite(&far_metrics, 1, sizeof(LevelEstimator::Metrics), stat_file_);
|
|
//fwrite(&near_metrics, 1, sizeof(LevelEstimator::Metrics), stat_file_);
|
|
}
|
|
|
|
rewind(far_file_);
|
|
rewind(near_file_);
|
|
test_count++;
|
|
printf("Loop %d of %lu\n", test_count, rev_ch_size * ch_size * fs_size);
|
|
}
|
|
}
|
|
}
|
|
if (!kReadStatFile) {
|
|
if (stat_file_ != NULL) {
|
|
ASSERT_EQ(0, fclose(stat_file_));
|
|
}
|
|
stat_file_ = NULL;
|
|
}
|
|
}
|
|
|
|
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());
|
|
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->echo_cancellation()->set_device_sample_rate_hz(4000));
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->echo_cancellation()->set_device_sample_rate_hz(100000));
|
|
|
|
int rate[] = {16000, 44100, 48000};
|
|
for (size_t i = 0; i < sizeof(rate)/sizeof(*rate); i++) {
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->echo_cancellation()->set_device_sample_rate_hz(rate[i]));
|
|
EXPECT_EQ(rate[i],
|
|
apm_->echo_cancellation()->device_sample_rate_hz());
|
|
}
|
|
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->echo_cancellation()->set_suppression_level(
|
|
static_cast<EchoCancellation::SuppressionLevel>(-1)));
|
|
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->echo_cancellation()->set_suppression_level(
|
|
static_cast<EchoCancellation::SuppressionLevel>(4)));
|
|
|
|
EchoCancellation::SuppressionLevel level[] = {
|
|
EchoCancellation::kLowSuppression,
|
|
EchoCancellation::kModerateSuppression,
|
|
EchoCancellation::kHighSuppression,
|
|
};
|
|
for (size_t i = 0; i < sizeof(level)/sizeof(*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());
|
|
|
|
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());
|
|
}
|
|
|
|
TEST_F(ApmTest, EchoControlMobile) {
|
|
// AECM won't use super-wideband.
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_sample_rate_hz(32000));
|
|
EXPECT_EQ(apm_->kBadSampleRateError, apm_->echo_control_mobile()->Enable(true));
|
|
EXPECT_EQ(apm_->kNoError, apm_->set_sample_rate_hz(16000));
|
|
// Turn AECM on (and AEC off)
|
|
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 < sizeof(mode)/sizeof(*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());
|
|
// 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_->kBadParameterError,
|
|
apm_->gain_control()->set_mode(static_cast<GainControl::Mode>(-1)));
|
|
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->gain_control()->set_mode(static_cast<GainControl::Mode>(3)));
|
|
|
|
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 < sizeof(mode)/sizeof(*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 < sizeof(level_dbfs)/sizeof(*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 < sizeof(gain_db)/sizeof(*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 < sizeof(min_level)/sizeof(*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 < sizeof(min_level)/sizeof(*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());
|
|
}
|
|
|
|
TEST_F(ApmTest, NoiseSuppression) {
|
|
// Tesing invalid suppression levels
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->noise_suppression()->set_level(
|
|
static_cast<NoiseSuppression::Level>(-1)));
|
|
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->noise_suppression()->set_level(
|
|
static_cast<NoiseSuppression::Level>(5)));
|
|
|
|
// Tesing valid suppression levels
|
|
NoiseSuppression::Level level[] = {
|
|
NoiseSuppression::kLow,
|
|
NoiseSuppression::kModerate,
|
|
NoiseSuppression::kHigh,
|
|
NoiseSuppression::kVeryHigh
|
|
};
|
|
for (size_t i = 0; i < sizeof(level)/sizeof(*level); i++) {
|
|
EXPECT_EQ(apm_->kNoError,
|
|
apm_->noise_suppression()->set_level(level[i]));
|
|
EXPECT_EQ(level[i], apm_->noise_suppression()->level());
|
|
}
|
|
|
|
// Turing 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) {
|
|
// Turing 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) {
|
|
// Turing Level estimator on/off
|
|
EXPECT_EQ(apm_->kUnsupportedComponentError,
|
|
apm_->level_estimator()->Enable(true));
|
|
EXPECT_FALSE(apm_->level_estimator()->is_enabled());
|
|
EXPECT_EQ(apm_->kUnsupportedComponentError,
|
|
apm_->level_estimator()->Enable(false));
|
|
EXPECT_FALSE(apm_->level_estimator()->is_enabled());
|
|
}
|
|
|
|
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());
|
|
|
|
// Tesing invalid likelihoods
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->voice_detection()->set_likelihood(
|
|
static_cast<VoiceDetection::Likelihood>(-1)));
|
|
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->voice_detection()->set_likelihood(
|
|
static_cast<VoiceDetection::Likelihood>(5)));
|
|
|
|
// Tesing valid likelihoods
|
|
VoiceDetection::Likelihood likelihood[] = {
|
|
VoiceDetection::kVeryLowLikelihood,
|
|
VoiceDetection::kLowLikelihood,
|
|
VoiceDetection::kModerateLikelihood,
|
|
VoiceDetection::kHighLikelihood
|
|
};
|
|
for (size_t i = 0; i < sizeof(likelihood)/sizeof(*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
|
|
// Tesing invalid frame sizes
|
|
EXPECT_EQ(apm_->kBadParameterError,
|
|
apm_->voice_detection()->set_frame_size_ms(12));
|
|
|
|
// Tesing 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());
|
|
}
|
|
*/
|
|
|
|
// Turing 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());
|
|
|
|
// TODO(bjornv): Add tests for streamed voice; stream_has_voice()
|
|
}
|
|
|
|
// Below are some ideas for tests from VPM.
|
|
|
|
/*TEST_F(VideoProcessingModuleTest, GetVersionTest)
|
|
{
|
|
}
|
|
|
|
TEST_F(VideoProcessingModuleTest, HandleNullBuffer)
|
|
{
|
|
}
|
|
|
|
TEST_F(VideoProcessingModuleTest, HandleBadSize)
|
|
{
|
|
}
|
|
|
|
TEST_F(VideoProcessingModuleTest, IdenticalResultsAfterReset)
|
|
{
|
|
}
|
|
*/
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
ApmEnvironment* env = new ApmEnvironment;
|
|
::testing::AddGlobalTestEnvironment(env);
|
|
|
|
return RUN_ALL_TESTS();
|
|
}
|
|
}
|