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