Move output_mixer_unittest.cc to utility_unittest.cc.
This reflects a move of the tested code in:
https://webrtc-codereview.appspot.com/11019005/
TBR=xians
Review URL: https://webrtc-codereview.appspot.com/11449004
git-svn-id: http://webrtc.googlecode.com/svn/trunk@5866 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/voice_engine/utility_unittest.cc b/webrtc/voice_engine/utility_unittest.cc
new file mode 100644
index 0000000..a5d0bcd
--- /dev/null
+++ b/webrtc/voice_engine/utility_unittest.cc
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <math.h>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/common_audio/resampler/include/push_resampler.h"
+#include "webrtc/modules/interface/module_common_types.h"
+#include "webrtc/voice_engine/utility.h"
+#include "webrtc/voice_engine/voice_engine_defines.h"
+
+namespace webrtc {
+namespace voe {
+namespace {
+
+enum FunctionToTest {
+ TestRemixAndResample,
+ TestDownConvertToCodecFormat
+};
+
+class UtilityTest : public ::testing::Test {
+ protected:
+ UtilityTest() {
+ src_frame_.sample_rate_hz_ = 16000;
+ src_frame_.samples_per_channel_ = src_frame_.sample_rate_hz_ / 100;
+ src_frame_.num_channels_ = 1;
+ dst_frame_.CopyFrom(src_frame_);
+ golden_frame_.CopyFrom(src_frame_);
+ }
+
+ void RunResampleTest(int src_channels, int src_sample_rate_hz,
+ int dst_channels, int dst_sample_rate_hz,
+ FunctionToTest function);
+
+ PushResampler resampler_;
+ AudioFrame src_frame_;
+ AudioFrame dst_frame_;
+ AudioFrame golden_frame_;
+};
+
+// Sets the signal value to increase by |data| with every sample. Floats are
+// used so non-integer values result in rounding error, but not an accumulating
+// error.
+void SetMonoFrame(AudioFrame* frame, float data, int sample_rate_hz) {
+ memset(frame->data_, 0, sizeof(frame->data_));
+ frame->num_channels_ = 1;
+ frame->sample_rate_hz_ = sample_rate_hz;
+ frame->samples_per_channel_ = sample_rate_hz / 100;
+ for (int i = 0; i < frame->samples_per_channel_; i++) {
+ frame->data_[i] = data * i;
+ }
+}
+
+// Keep the existing sample rate.
+void SetMonoFrame(AudioFrame* frame, float data) {
+ SetMonoFrame(frame, data, frame->sample_rate_hz_);
+}
+
+// Sets the signal value to increase by |left| and |right| with every sample in
+// each channel respectively.
+void SetStereoFrame(AudioFrame* frame, float left, float right,
+ int sample_rate_hz) {
+ memset(frame->data_, 0, sizeof(frame->data_));
+ frame->num_channels_ = 2;
+ frame->sample_rate_hz_ = sample_rate_hz;
+ frame->samples_per_channel_ = sample_rate_hz / 100;
+ for (int i = 0; i < frame->samples_per_channel_; i++) {
+ frame->data_[i * 2] = left * i;
+ frame->data_[i * 2 + 1] = right * i;
+ }
+}
+
+// Keep the existing sample rate.
+void SetStereoFrame(AudioFrame* frame, float left, float right) {
+ SetStereoFrame(frame, left, right, frame->sample_rate_hz_);
+}
+
+void VerifyParams(const AudioFrame& ref_frame, const AudioFrame& test_frame) {
+ EXPECT_EQ(ref_frame.num_channels_, test_frame.num_channels_);
+ EXPECT_EQ(ref_frame.samples_per_channel_, test_frame.samples_per_channel_);
+ EXPECT_EQ(ref_frame.sample_rate_hz_, test_frame.sample_rate_hz_);
+}
+
+// Computes the best SNR based on the error between |ref_frame| and
+// |test_frame|. It allows for up to a |max_delay| in samples between the
+// signals to compensate for the resampling delay.
+float ComputeSNR(const AudioFrame& ref_frame, const AudioFrame& test_frame,
+ int max_delay) {
+ VerifyParams(ref_frame, test_frame);
+ float best_snr = 0;
+ int best_delay = 0;
+ for (int delay = 0; delay <= max_delay; delay++) {
+ float mse = 0;
+ float variance = 0;
+ for (int i = 0; i < ref_frame.samples_per_channel_ *
+ ref_frame.num_channels_ - delay; i++) {
+ int error = ref_frame.data_[i] - test_frame.data_[i + delay];
+ mse += error * error;
+ variance += ref_frame.data_[i] * ref_frame.data_[i];
+ }
+ float snr = 100; // We assign 100 dB to the zero-error case.
+ if (mse > 0)
+ snr = 10 * log10(variance / mse);
+ if (snr > best_snr) {
+ best_snr = snr;
+ best_delay = delay;
+ }
+ }
+ printf("SNR=%.1f dB at delay=%d\n", best_snr, best_delay);
+ return best_snr;
+}
+
+void VerifyFramesAreEqual(const AudioFrame& ref_frame,
+ const AudioFrame& test_frame) {
+ VerifyParams(ref_frame, test_frame);
+ for (int i = 0; i < ref_frame.samples_per_channel_ * ref_frame.num_channels_;
+ i++) {
+ EXPECT_EQ(ref_frame.data_[i], test_frame.data_[i]);
+ }
+}
+
+void UtilityTest::RunResampleTest(int src_channels,
+ int src_sample_rate_hz,
+ int dst_channels,
+ int dst_sample_rate_hz,
+ FunctionToTest function) {
+ PushResampler resampler; // Create a new one with every test.
+ const int16_t kSrcLeft = 30; // Shouldn't overflow for any used sample rate.
+ const int16_t kSrcRight = 15;
+ const float resampling_factor = (1.0 * src_sample_rate_hz) /
+ dst_sample_rate_hz;
+ const float dst_left = resampling_factor * kSrcLeft;
+ const float dst_right = resampling_factor * kSrcRight;
+ const float dst_mono = (dst_left + dst_right) / 2;
+ if (src_channels == 1)
+ SetMonoFrame(&src_frame_, kSrcLeft, src_sample_rate_hz);
+ else
+ SetStereoFrame(&src_frame_, kSrcLeft, kSrcRight, src_sample_rate_hz);
+
+ if (dst_channels == 1) {
+ SetMonoFrame(&dst_frame_, 0, dst_sample_rate_hz);
+ if (src_channels == 1)
+ SetMonoFrame(&golden_frame_, dst_left, dst_sample_rate_hz);
+ else
+ SetMonoFrame(&golden_frame_, dst_mono, dst_sample_rate_hz);
+ } else {
+ SetStereoFrame(&dst_frame_, 0, 0, dst_sample_rate_hz);
+ if (src_channels == 1)
+ SetStereoFrame(&golden_frame_, dst_left, dst_left, dst_sample_rate_hz);
+ else
+ SetStereoFrame(&golden_frame_, dst_left, dst_right, dst_sample_rate_hz);
+ }
+
+ // The sinc resampler has a known delay, which we compute here. Multiplying by
+ // two gives us a crude maximum for any resampling, as the old resampler
+ // typically (but not always) has lower delay.
+ static const int kInputKernelDelaySamples = 16;
+ const int max_delay = static_cast<double>(dst_sample_rate_hz)
+ / src_sample_rate_hz * kInputKernelDelaySamples * dst_channels * 2;
+ printf("(%d, %d Hz) -> (%d, %d Hz) ", // SNR reported on the same line later.
+ src_channels, src_sample_rate_hz, dst_channels, dst_sample_rate_hz);
+ if (function == TestRemixAndResample) {
+ RemixAndResample(src_frame_, &resampler, &dst_frame_);
+ } else {
+ int16_t mono_buffer[kMaxMonoDataSizeSamples];
+ DownConvertToCodecFormat(src_frame_.data_,
+ src_frame_.samples_per_channel_,
+ src_frame_.num_channels_,
+ src_frame_.sample_rate_hz_,
+ dst_frame_.num_channels_,
+ dst_frame_.sample_rate_hz_,
+ mono_buffer,
+ &resampler,
+ &dst_frame_);
+ }
+
+ if (src_sample_rate_hz == 96000 && dst_sample_rate_hz == 8000) {
+ // The sinc resampler gives poor SNR at this extreme conversion, but we
+ // expect to see this rarely in practice.
+ EXPECT_GT(ComputeSNR(golden_frame_, dst_frame_, max_delay), 14.0f);
+ } else {
+ EXPECT_GT(ComputeSNR(golden_frame_, dst_frame_, max_delay), 46.0f);
+ }
+}
+
+TEST_F(UtilityTest, RemixAndResampleCopyFrameSucceeds) {
+ // Stereo -> stereo.
+ SetStereoFrame(&src_frame_, 10, 10);
+ SetStereoFrame(&dst_frame_, 0, 0);
+ RemixAndResample(src_frame_, &resampler_, &dst_frame_);
+ VerifyFramesAreEqual(src_frame_, dst_frame_);
+
+ // Mono -> mono.
+ SetMonoFrame(&src_frame_, 20);
+ SetMonoFrame(&dst_frame_, 0);
+ RemixAndResample(src_frame_, &resampler_, &dst_frame_);
+ VerifyFramesAreEqual(src_frame_, dst_frame_);
+}
+
+TEST_F(UtilityTest, RemixAndResampleMixingOnlySucceeds) {
+ // Stereo -> mono.
+ SetStereoFrame(&dst_frame_, 0, 0);
+ SetMonoFrame(&src_frame_, 10);
+ SetStereoFrame(&golden_frame_, 10, 10);
+ RemixAndResample(src_frame_, &resampler_, &dst_frame_);
+ VerifyFramesAreEqual(dst_frame_, golden_frame_);
+
+ // Mono -> stereo.
+ SetMonoFrame(&dst_frame_, 0);
+ SetStereoFrame(&src_frame_, 10, 20);
+ SetMonoFrame(&golden_frame_, 15);
+ RemixAndResample(src_frame_, &resampler_, &dst_frame_);
+ VerifyFramesAreEqual(golden_frame_, dst_frame_);
+}
+
+TEST_F(UtilityTest, RemixAndResampleSucceeds) {
+ const int kSampleRates[] = {8000, 16000, 32000, 44100, 48000, 96000};
+ const int kSampleRatesSize = sizeof(kSampleRates) / sizeof(*kSampleRates);
+ const int kChannels[] = {1, 2};
+ const int kChannelsSize = sizeof(kChannels) / sizeof(*kChannels);
+ for (int src_rate = 0; src_rate < kSampleRatesSize; src_rate++) {
+ for (int dst_rate = 0; dst_rate < kSampleRatesSize; dst_rate++) {
+ for (int src_channel = 0; src_channel < kChannelsSize; src_channel++) {
+ for (int dst_channel = 0; dst_channel < kChannelsSize; dst_channel++) {
+ RunResampleTest(kChannels[src_channel], kSampleRates[src_rate],
+ kChannels[dst_channel], kSampleRates[dst_rate],
+ TestRemixAndResample);
+ }
+ }
+ }
+ }
+}
+
+TEST_F(UtilityTest, ConvertToCodecFormatSucceeds) {
+ const int kSampleRates[] = {8000, 16000, 32000, 44100, 48000, 96000};
+ const int kSampleRatesSize = sizeof(kSampleRates) / sizeof(*kSampleRates);
+ const int kChannels[] = {1, 2};
+ const int kChannelsSize = sizeof(kChannels) / sizeof(*kChannels);
+ for (int src_rate = 0; src_rate < kSampleRatesSize; src_rate++) {
+ for (int dst_rate = 0; dst_rate < kSampleRatesSize; dst_rate++) {
+ for (int src_channel = 0; src_channel < kChannelsSize; src_channel++) {
+ for (int dst_channel = 0; dst_channel < kChannelsSize; dst_channel++) {
+ if (dst_rate <= src_rate && dst_channel <= src_channel) {
+ RunResampleTest(kChannels[src_channel], kSampleRates[src_rate],
+ kChannels[src_channel], kSampleRates[dst_rate],
+ TestDownConvertToCodecFormat);
+ }
+ }
+ }
+ }
+ }
+}
+
+} // namespace
+} // namespace voe
+} // namespace webrtc