1 /*
2 * Copyright (c) 2016 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 #include <vector>
11
12 #include "api/array_view.h"
13 #include "modules/audio_processing/audio_buffer.h"
14 #include "modules/audio_processing/gain_control_impl.h"
15 #include "modules/audio_processing/test/audio_buffer_tools.h"
16 #include "modules/audio_processing/test/bitexactness_tools.h"
17 #include "test/gtest.h"
18
19 namespace webrtc {
20 namespace {
21
22 const int kNumFramesToProcess = 100;
23
ProcessOneFrame(int sample_rate_hz,AudioBuffer * render_audio_buffer,AudioBuffer * capture_audio_buffer,GainControlImpl * gain_controller)24 void ProcessOneFrame(int sample_rate_hz,
25 AudioBuffer* render_audio_buffer,
26 AudioBuffer* capture_audio_buffer,
27 GainControlImpl* gain_controller) {
28 if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
29 render_audio_buffer->SplitIntoFrequencyBands();
30 capture_audio_buffer->SplitIntoFrequencyBands();
31 }
32
33 std::vector<int16_t> render_audio;
34 GainControlImpl::PackRenderAudioBuffer(render_audio_buffer, &render_audio);
35 gain_controller->ProcessRenderAudio(render_audio);
36 gain_controller->AnalyzeCaptureAudio(capture_audio_buffer);
37 gain_controller->ProcessCaptureAudio(capture_audio_buffer, false);
38
39 if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
40 capture_audio_buffer->MergeFrequencyBands();
41 }
42 }
43
SetupComponent(int sample_rate_hz,GainControl::Mode mode,int target_level_dbfs,int stream_analog_level,int compression_gain_db,bool enable_limiter,int analog_level_min,int analog_level_max,GainControlImpl * gain_controller)44 void SetupComponent(int sample_rate_hz,
45 GainControl::Mode mode,
46 int target_level_dbfs,
47 int stream_analog_level,
48 int compression_gain_db,
49 bool enable_limiter,
50 int analog_level_min,
51 int analog_level_max,
52 GainControlImpl* gain_controller) {
53 gain_controller->Initialize(1, sample_rate_hz);
54 GainControl* gc = static_cast<GainControl*>(gain_controller);
55 gc->Enable(true);
56 gc->set_mode(mode);
57 gc->set_stream_analog_level(stream_analog_level);
58 gc->set_target_level_dbfs(target_level_dbfs);
59 gc->set_compression_gain_db(compression_gain_db);
60 gc->enable_limiter(enable_limiter);
61 gc->set_analog_level_limits(analog_level_min, analog_level_max);
62 }
63
RunBitExactnessTest(int sample_rate_hz,size_t num_channels,GainControl::Mode mode,int target_level_dbfs,int stream_analog_level,int compression_gain_db,bool enable_limiter,int analog_level_min,int analog_level_max,int achieved_stream_analog_level_reference,rtc::ArrayView<const float> output_reference)64 void RunBitExactnessTest(int sample_rate_hz,
65 size_t num_channels,
66 GainControl::Mode mode,
67 int target_level_dbfs,
68 int stream_analog_level,
69 int compression_gain_db,
70 bool enable_limiter,
71 int analog_level_min,
72 int analog_level_max,
73 int achieved_stream_analog_level_reference,
74 rtc::ArrayView<const float> output_reference) {
75 rtc::CriticalSection crit_render;
76 rtc::CriticalSection crit_capture;
77 GainControlImpl gain_controller(&crit_render, &crit_capture);
78 SetupComponent(sample_rate_hz, mode, target_level_dbfs, stream_analog_level,
79 compression_gain_db, enable_limiter, analog_level_min,
80 analog_level_max, &gain_controller);
81
82 const int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
83 const StreamConfig render_config(sample_rate_hz, num_channels, false);
84 AudioBuffer render_buffer(
85 render_config.num_frames(), render_config.num_channels(),
86 render_config.num_frames(), 1, render_config.num_frames());
87 test::InputAudioFile render_file(
88 test::GetApmRenderTestVectorFileName(sample_rate_hz));
89 std::vector<float> render_input(samples_per_channel * num_channels);
90
91 const StreamConfig capture_config(sample_rate_hz, num_channels, false);
92 AudioBuffer capture_buffer(
93 capture_config.num_frames(), capture_config.num_channels(),
94 capture_config.num_frames(), 1, capture_config.num_frames());
95 test::InputAudioFile capture_file(
96 test::GetApmCaptureTestVectorFileName(sample_rate_hz));
97 std::vector<float> capture_input(samples_per_channel * num_channels);
98
99 for (int frame_no = 0; frame_no < kNumFramesToProcess; ++frame_no) {
100 ReadFloatSamplesFromStereoFile(samples_per_channel, num_channels,
101 &render_file, render_input);
102 ReadFloatSamplesFromStereoFile(samples_per_channel, num_channels,
103 &capture_file, capture_input);
104
105 test::CopyVectorToAudioBuffer(render_config, render_input, &render_buffer);
106 test::CopyVectorToAudioBuffer(capture_config, capture_input,
107 &capture_buffer);
108
109 ProcessOneFrame(sample_rate_hz, &render_buffer, &capture_buffer,
110 &gain_controller);
111 }
112
113 // Extract and verify the test results.
114 std::vector<float> capture_output;
115 test::ExtractVectorFromAudioBuffer(capture_config, &capture_buffer,
116 &capture_output);
117
118 EXPECT_EQ(achieved_stream_analog_level_reference,
119 gain_controller.stream_analog_level());
120
121 // Compare the output with the reference. Only the first values of the output
122 // from last frame processed are compared in order not having to specify all
123 // preceeding frames as testvectors. As the algorithm being tested has a
124 // memory, testing only the last frame implicitly also tests the preceeding
125 // frames.
126 const float kElementErrorBound = 1.0f / 32768.0f;
127 EXPECT_TRUE(test::VerifyDeinterleavedArray(
128 capture_config.num_frames(), capture_config.num_channels(),
129 output_reference, capture_output, kElementErrorBound));
130 }
131
132 } // namespace
133
134 // TODO(peah): Activate all these tests for ARM and ARM64 once the issue on the
135 // Chromium ARM and ARM64 boths have been identified. This is tracked in the
136 // issue https://bugs.chromium.org/p/webrtc/issues/detail?id=5711.
137
138 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
139 defined(WEBRTC_ANDROID))
TEST(GainControlBitExactnessTest,Mono8kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100)140 TEST(GainControlBitExactnessTest,
141 Mono8kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
142 #else
143 TEST(GainControlBitExactnessTest,
144 DISABLED_Mono8kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
145 #endif
146 const int kStreamAnalogLevelReference = 50;
147 const float kOutputReference[] = {-0.006622f, -0.002747f, 0.001587f};
148 RunBitExactnessTest(8000, 1, GainControl::Mode::kAdaptiveAnalog, 10, 50, 5,
149 true, 0, 100, kStreamAnalogLevelReference,
150 kOutputReference);
151 }
152
153 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
154 defined(WEBRTC_ANDROID))
155 TEST(GainControlBitExactnessTest,
156 Mono16kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
157 #else
158 TEST(GainControlBitExactnessTest,
159 DISABLED_Mono16kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
160 #endif
161 const int kStreamAnalogLevelReference = 50;
162 const float kOutputReference[] = {-0.006561f, -0.004608f, -0.002899f};
163 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveAnalog, 10, 50, 5,
164 true, 0, 100, kStreamAnalogLevelReference,
165 kOutputReference);
166 }
167
168 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
169 defined(WEBRTC_ANDROID))
170 TEST(GainControlBitExactnessTest,
171 Stereo16kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
172 #else
173 TEST(GainControlBitExactnessTest,
174 DISABLED_Stereo16kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
175 #endif
176 const int kStreamAnalogLevelReference = 50;
177 const float kOutputReference[] = {-0.027313f, -0.015900f, -0.028107f,
178 -0.027313f, -0.015900f, -0.028107f};
179 RunBitExactnessTest(16000, 2, GainControl::Mode::kAdaptiveAnalog, 10, 50, 5,
180 true, 0, 100, kStreamAnalogLevelReference,
181 kOutputReference);
182 }
183
184 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
185 defined(WEBRTC_ANDROID))
186 TEST(GainControlBitExactnessTest,
187 Mono32kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
188 #else
189 TEST(GainControlBitExactnessTest,
190 DISABLED_Mono32kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
191 #endif
192 const int kStreamAnalogLevelReference = 50;
193 const float kOutputReference[] = {-0.010162f, -0.009155f, -0.008301f};
194 RunBitExactnessTest(32000, 1, GainControl::Mode::kAdaptiveAnalog, 10, 50, 5,
195 true, 0, 100, kStreamAnalogLevelReference,
196 kOutputReference);
197 }
198
199 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
200 defined(WEBRTC_ANDROID))
201 TEST(GainControlBitExactnessTest,
202 Mono48kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
203 #else
204 TEST(GainControlBitExactnessTest,
205 DISABLED_Mono48kHz_AdaptiveAnalog_Tl10_SL50_CG5_Lim_AL0_100) {
206 #endif
207 const int kStreamAnalogLevelReference = 50;
208 const float kOutputReference[] = {-0.010162f, -0.009155f, -0.008301f};
209 RunBitExactnessTest(32000, 1, GainControl::Mode::kAdaptiveAnalog, 10, 50, 5,
210 true, 0, 100, kStreamAnalogLevelReference,
211 kOutputReference);
212 }
213
214 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
215 defined(WEBRTC_ANDROID))
216 TEST(GainControlBitExactnessTest,
217 Mono8kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
218 #else
219 TEST(GainControlBitExactnessTest,
220 DISABLED_Mono8kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
221 #endif
222 const int kStreamAnalogLevelReference = 50;
223 const float kOutputReference[] = {-0.004028f, -0.001678f, 0.000946f};
224 RunBitExactnessTest(8000, 1, GainControl::Mode::kAdaptiveDigital, 10, 50, 5,
225 true, 0, 100, kStreamAnalogLevelReference,
226 kOutputReference);
227 }
228
229 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
230 defined(WEBRTC_ANDROID))
231 TEST(GainControlBitExactnessTest,
232 Mono16kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
233 #else
234 TEST(GainControlBitExactnessTest,
235 DISABLED_Mono16kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
236 #endif
237 const int kStreamAnalogLevelReference = 50;
238 const float kOutputReference[] = {-0.003967f, -0.002777f, -0.001770f};
239 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveDigital, 10, 50, 5,
240 true, 0, 100, kStreamAnalogLevelReference,
241 kOutputReference);
242 }
243
244 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
245 defined(WEBRTC_ANDROID))
246 TEST(GainControlBitExactnessTest,
247 Stereo16kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
248 #else
249 TEST(GainControlBitExactnessTest,
250 DISABLED_Stereo16kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
251 #endif
252 const int kStreamAnalogLevelReference = 50;
253 const float kOutputReference[] = {-0.015411f, -0.008972f, -0.015839f,
254 -0.015411f, -0.008972f, -0.015839f};
255 RunBitExactnessTest(16000, 2, GainControl::Mode::kAdaptiveDigital, 10, 50, 5,
256 true, 0, 100, kStreamAnalogLevelReference,
257 kOutputReference);
258 }
259
260 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
261 defined(WEBRTC_ANDROID))
262 TEST(GainControlBitExactnessTest,
263 Mono32kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
264 #else
265 TEST(GainControlBitExactnessTest,
266 DISABLED_Mono32kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
267 #endif
268 const int kStreamAnalogLevelReference = 50;
269 const float kOutputReference[] = {-0.006104f, -0.005524f, -0.004974f};
270 RunBitExactnessTest(32000, 1, GainControl::Mode::kAdaptiveDigital, 10, 50, 5,
271 true, 0, 100, kStreamAnalogLevelReference,
272 kOutputReference);
273 }
274
275 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
276 defined(WEBRTC_ANDROID))
277 TEST(GainControlBitExactnessTest,
278 Mono48kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
279 #else
280 TEST(GainControlBitExactnessTest,
281 DISABLED_Mono48kHz_AdaptiveDigital_Tl10_SL50_CG5_Lim_AL0_100) {
282 #endif
283 const int kStreamAnalogLevelReference = 50;
284 const float kOutputReference[] = {-0.006104f, -0.005524f, -0.004974f};
285 RunBitExactnessTest(32000, 1, GainControl::Mode::kAdaptiveDigital, 10, 50, 5,
286 true, 0, 100, kStreamAnalogLevelReference,
287 kOutputReference);
288 }
289
290 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
291 defined(WEBRTC_ANDROID))
292 TEST(GainControlBitExactnessTest,
293 Mono8kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
294 #else
295 TEST(GainControlBitExactnessTest,
296 DISABLED_Mono8kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
297 #endif
298 const int kStreamAnalogLevelReference = 50;
299 const float kOutputReference[] = {-0.011871f, -0.004944f, 0.002838f};
300 RunBitExactnessTest(8000, 1, GainControl::Mode::kFixedDigital, 10, 50, 5,
301 true, 0, 100, kStreamAnalogLevelReference,
302 kOutputReference);
303 }
304
305 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
306 defined(WEBRTC_ANDROID))
307 TEST(GainControlBitExactnessTest,
308 Mono16kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
309 #else
310 TEST(GainControlBitExactnessTest,
311 DISABLED_Mono16kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
312 #endif
313 const int kStreamAnalogLevelReference = 50;
314 const float kOutputReference[] = {-0.011749f, -0.008270f, -0.005219f};
315 RunBitExactnessTest(16000, 1, GainControl::Mode::kFixedDigital, 10, 50, 5,
316 true, 0, 100, kStreamAnalogLevelReference,
317 kOutputReference);
318 }
319
320 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
321 defined(WEBRTC_ANDROID))
322 TEST(GainControlBitExactnessTest,
323 Stereo16kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
324 #else
325 TEST(GainControlBitExactnessTest,
326 DISABLED_Stereo16kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
327 #endif
328 const int kStreamAnalogLevelReference = 50;
329 const float kOutputReference[] = {-0.048950f, -0.028503f, -0.050354f,
330 -0.048950f, -0.028503f, -0.050354f};
331 RunBitExactnessTest(16000, 2, GainControl::Mode::kFixedDigital, 10, 50, 5,
332 true, 0, 100, kStreamAnalogLevelReference,
333 kOutputReference);
334 }
335
336 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
337 defined(WEBRTC_ANDROID))
338 TEST(GainControlBitExactnessTest,
339 Mono32kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
340 #else
341 TEST(GainControlBitExactnessTest,
342 DISABLED_Mono32kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
343 #endif
344 const int kStreamAnalogLevelReference = 50;
345 const float kOutputReference[] = {-0.018188f, -0.016418f, -0.014862f};
346 RunBitExactnessTest(32000, 1, GainControl::Mode::kFixedDigital, 10, 50, 5,
347 true, 0, 100, kStreamAnalogLevelReference,
348 kOutputReference);
349 }
350
351 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
352 defined(WEBRTC_ANDROID))
353 TEST(GainControlBitExactnessTest,
354 Mono48kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
355 #else
356 TEST(GainControlBitExactnessTest,
357 DISABLED_Mono48kHz_FixedDigital_Tl10_SL50_CG5_Lim_AL0_100) {
358 #endif
359 const int kStreamAnalogLevelReference = 50;
360 const float kOutputReference[] = {-0.018188f, -0.016418f, -0.014862f};
361 RunBitExactnessTest(32000, 1, GainControl::Mode::kFixedDigital, 10, 50, 5,
362 true, 0, 100, kStreamAnalogLevelReference,
363 kOutputReference);
364 }
365
366 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
367 defined(WEBRTC_ANDROID))
368 TEST(GainControlBitExactnessTest,
369 Mono16kHz_AdaptiveAnalog_Tl10_SL10_CG5_Lim_AL0_100) {
370 #else
371 TEST(GainControlBitExactnessTest,
372 DISABLED_Mono16kHz_AdaptiveAnalog_Tl10_SL10_CG5_Lim_AL0_100) {
373 #endif
374 const int kStreamAnalogLevelReference = 12;
375 const float kOutputReference[] = {-0.006561f, -0.004608f, -0.002899f};
376 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveAnalog, 10, 10, 5,
377 true, 0, 100, kStreamAnalogLevelReference,
378 kOutputReference);
379 }
380
381 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
382 defined(WEBRTC_ANDROID))
383 TEST(GainControlBitExactnessTest,
384 Mono16kHz_AdaptiveAnalog_Tl10_SL100_CG5_Lim_AL70_80) {
385 #else
386 TEST(GainControlBitExactnessTest,
387 DISABLED_Mono16kHz_AdaptiveAnalog_Tl10_SL100_CG5_Lim_AL70_80) {
388 #endif
389 const int kStreamAnalogLevelReference = 100;
390 const float kOutputReference[] = {-0.003998f, -0.002808f, -0.001770f};
391 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveAnalog, 10, 100, 5,
392 true, 70, 80, kStreamAnalogLevelReference,
393 kOutputReference);
394 }
395
396 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
397 defined(WEBRTC_ANDROID))
398 TEST(GainControlBitExactnessTest,
399 Mono16kHz_AdaptiveDigital_Tl10_SL100_CG5_NoLim_AL0_100) {
400 #else
401 TEST(GainControlBitExactnessTest,
402 DISABLED_Mono16kHz_AdaptiveDigital_Tl10_SL100_CG5_NoLim_AL0_100) {
403 #endif
404 const int kStreamAnalogLevelReference = 100;
405 const float kOutputReference[] = {-0.004028f, -0.002838f, -0.001770f};
406 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveDigital, 10, 100, 5,
407 false, 0, 100, kStreamAnalogLevelReference,
408 kOutputReference);
409 }
410
411 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
412 defined(WEBRTC_ANDROID))
413 TEST(GainControlBitExactnessTest,
414 Mono16kHz_AdaptiveDigital_Tl40_SL100_CG5_Lim_AL0_100) {
415 #else
416 TEST(GainControlBitExactnessTest,
417 DISABLED_Mono16kHz_AdaptiveDigital_Tl40_SL100_CG5_Lim_AL0_100) {
418 #endif
419 const int kStreamAnalogLevelReference = 100;
420 const float kOutputReference[] = {-0.008728f, -0.006134f, -0.003845f};
421 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveDigital, 40, 100, 5,
422 true, 0, 100, kStreamAnalogLevelReference,
423 kOutputReference);
424 }
425
426 #if !(defined(WEBRTC_ARCH_ARM64) || defined(WEBRTC_ARCH_ARM) || \
427 defined(WEBRTC_ANDROID))
428 TEST(GainControlBitExactnessTest,
429 Mono16kHz_AdaptiveDigital_Tl10_SL100_CG30_Lim_AL0_100) {
430 #else
431 TEST(GainControlBitExactnessTest,
432 DISABLED_Mono16kHz_AdaptiveDigital_Tl10_SL100_CG30_Lim_AL0_100) {
433 #endif
434 const int kStreamAnalogLevelReference = 100;
435 const float kOutputReference[] = {-0.005859f, -0.004120f, -0.002594f};
436 RunBitExactnessTest(16000, 1, GainControl::Mode::kAdaptiveDigital, 10, 100,
437 30, true, 0, 100, kStreamAnalogLevelReference,
438 kOutputReference);
439 }
440
441 } // namespace webrtc
442