1 /*
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <cmath>
12 #include <algorithm>
13 #include <vector>
14
15 #include "testing/gtest/include/gtest/gtest.h"
16 #include "webrtc/base/format_macros.h"
17 #include "webrtc/base/scoped_ptr.h"
18 #include "webrtc/common_audio/audio_converter.h"
19 #include "webrtc/common_audio/channel_buffer.h"
20 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
21
22 namespace webrtc {
23
24 typedef rtc::scoped_ptr<ChannelBuffer<float>> ScopedBuffer;
25
26 // Sets the signal value to increase by |data| with every sample.
CreateBuffer(const std::vector<float> & data,int frames)27 ScopedBuffer CreateBuffer(const std::vector<float>& data, int frames) {
28 const int num_channels = static_cast<int>(data.size());
29 ScopedBuffer sb(new ChannelBuffer<float>(frames, num_channels));
30 for (int i = 0; i < num_channels; ++i)
31 for (int j = 0; j < frames; ++j)
32 sb->channels()[i][j] = data[i] * j;
33 return sb;
34 }
35
VerifyParams(const ChannelBuffer<float> & ref,const ChannelBuffer<float> & test)36 void VerifyParams(const ChannelBuffer<float>& ref,
37 const ChannelBuffer<float>& test) {
38 EXPECT_EQ(ref.num_channels(), test.num_channels());
39 EXPECT_EQ(ref.num_frames(), test.num_frames());
40 }
41
42 // Computes the best SNR based on the error between |ref_frame| and
43 // |test_frame|. It searches around |expected_delay| in samples between the
44 // signals to compensate for the resampling delay.
ComputeSNR(const ChannelBuffer<float> & ref,const ChannelBuffer<float> & test,size_t expected_delay)45 float ComputeSNR(const ChannelBuffer<float>& ref,
46 const ChannelBuffer<float>& test,
47 size_t expected_delay) {
48 VerifyParams(ref, test);
49 float best_snr = 0;
50 size_t best_delay = 0;
51
52 // Search within one sample of the expected delay.
53 for (size_t delay = std::max(expected_delay, static_cast<size_t>(1)) - 1;
54 delay <= std::min(expected_delay + 1, ref.num_frames());
55 ++delay) {
56 float mse = 0;
57 float variance = 0;
58 float mean = 0;
59 for (int i = 0; i < ref.num_channels(); ++i) {
60 for (size_t j = 0; j < ref.num_frames() - delay; ++j) {
61 float error = ref.channels()[i][j] - test.channels()[i][j + delay];
62 mse += error * error;
63 variance += ref.channels()[i][j] * ref.channels()[i][j];
64 mean += ref.channels()[i][j];
65 }
66 }
67
68 const size_t length = ref.num_channels() * (ref.num_frames() - delay);
69 mse /= length;
70 variance /= length;
71 mean /= length;
72 variance -= mean * mean;
73 float snr = 100; // We assign 100 dB to the zero-error case.
74 if (mse > 0)
75 snr = 10 * std::log10(variance / mse);
76 if (snr > best_snr) {
77 best_snr = snr;
78 best_delay = delay;
79 }
80 }
81 printf("SNR=%.1f dB at delay=%" PRIuS "\n", best_snr, best_delay);
82 return best_snr;
83 }
84
85 // Sets the source to a linearly increasing signal for which we can easily
86 // generate a reference. Runs the AudioConverter and ensures the output has
87 // sufficiently high SNR relative to the reference.
RunAudioConverterTest(int src_channels,int src_sample_rate_hz,int dst_channels,int dst_sample_rate_hz)88 void RunAudioConverterTest(int src_channels,
89 int src_sample_rate_hz,
90 int dst_channels,
91 int dst_sample_rate_hz) {
92 const float kSrcLeft = 0.0002f;
93 const float kSrcRight = 0.0001f;
94 const float resampling_factor = (1.f * src_sample_rate_hz) /
95 dst_sample_rate_hz;
96 const float dst_left = resampling_factor * kSrcLeft;
97 const float dst_right = resampling_factor * kSrcRight;
98 const float dst_mono = (dst_left + dst_right) / 2;
99 const int src_frames = src_sample_rate_hz / 100;
100 const int dst_frames = dst_sample_rate_hz / 100;
101
102 std::vector<float> src_data(1, kSrcLeft);
103 if (src_channels == 2)
104 src_data.push_back(kSrcRight);
105 ScopedBuffer src_buffer = CreateBuffer(src_data, src_frames);
106
107 std::vector<float> dst_data(1, 0);
108 std::vector<float> ref_data;
109 if (dst_channels == 1) {
110 if (src_channels == 1)
111 ref_data.push_back(dst_left);
112 else
113 ref_data.push_back(dst_mono);
114 } else {
115 dst_data.push_back(0);
116 ref_data.push_back(dst_left);
117 if (src_channels == 1)
118 ref_data.push_back(dst_left);
119 else
120 ref_data.push_back(dst_right);
121 }
122 ScopedBuffer dst_buffer = CreateBuffer(dst_data, dst_frames);
123 ScopedBuffer ref_buffer = CreateBuffer(ref_data, dst_frames);
124
125 // The sinc resampler has a known delay, which we compute here.
126 const size_t delay_frames = src_sample_rate_hz == dst_sample_rate_hz ? 0 :
127 static_cast<size_t>(
128 PushSincResampler::AlgorithmicDelaySeconds(src_sample_rate_hz) *
129 dst_sample_rate_hz);
130 printf("(%d, %d Hz) -> (%d, %d Hz) ", // SNR reported on the same line later.
131 src_channels, src_sample_rate_hz, dst_channels, dst_sample_rate_hz);
132
133 rtc::scoped_ptr<AudioConverter> converter = AudioConverter::Create(
134 src_channels, src_frames, dst_channels, dst_frames);
135 converter->Convert(src_buffer->channels(), src_buffer->size(),
136 dst_buffer->channels(), dst_buffer->size());
137
138 EXPECT_LT(43.f,
139 ComputeSNR(*ref_buffer.get(), *dst_buffer.get(), delay_frames));
140 }
141
TEST(AudioConverterTest,ConversionsPassSNRThreshold)142 TEST(AudioConverterTest, ConversionsPassSNRThreshold) {
143 const int kSampleRates[] = {8000, 16000, 32000, 44100, 48000};
144 const int kSampleRatesSize = sizeof(kSampleRates) / sizeof(*kSampleRates);
145 const int kChannels[] = {1, 2};
146 const int kChannelsSize = sizeof(kChannels) / sizeof(*kChannels);
147 for (int src_rate = 0; src_rate < kSampleRatesSize; ++src_rate) {
148 for (int dst_rate = 0; dst_rate < kSampleRatesSize; ++dst_rate) {
149 for (int src_channel = 0; src_channel < kChannelsSize; ++src_channel) {
150 for (int dst_channel = 0; dst_channel < kChannelsSize; ++dst_channel) {
151 RunAudioConverterTest(kChannels[src_channel], kSampleRates[src_rate],
152 kChannels[dst_channel], kSampleRates[dst_rate]);
153 }
154 }
155 }
156 }
157 }
158
159 } // namespace webrtc
160