1 /*
2  *  Copyright (c) 2017 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 "modules/audio_processing/gain_controller2.h"
12 
13 #include <algorithm>
14 #include <cmath>
15 #include <memory>
16 
17 #include "api/array_view.h"
18 #include "modules/audio_processing/agc2/agc2_testing_common.h"
19 #include "modules/audio_processing/audio_buffer.h"
20 #include "modules/audio_processing/test/audio_buffer_tools.h"
21 #include "modules/audio_processing/test/bitexactness_tools.h"
22 #include "rtc_base/checks.h"
23 #include "test/gtest.h"
24 
25 namespace webrtc {
26 namespace test {
27 namespace {
28 
SetAudioBufferSamples(float value,AudioBuffer * ab)29 void SetAudioBufferSamples(float value, AudioBuffer* ab) {
30   // Sets all the samples in |ab| to |value|.
31   for (size_t k = 0; k < ab->num_channels(); ++k) {
32     std::fill(ab->channels()[k], ab->channels()[k] + ab->num_frames(), value);
33   }
34 }
35 
RunAgc2WithConstantInput(GainController2 * agc2,float input_level,size_t num_frames,int sample_rate)36 float RunAgc2WithConstantInput(GainController2* agc2,
37                                float input_level,
38                                size_t num_frames,
39                                int sample_rate) {
40   const int num_samples = rtc::CheckedDivExact(sample_rate, 100);
41   AudioBuffer ab(sample_rate, 1, sample_rate, 1, sample_rate, 1);
42 
43   // Give time to the level estimator to converge.
44   for (size_t i = 0; i < num_frames + 1; ++i) {
45     SetAudioBufferSamples(input_level, &ab);
46     agc2->Process(&ab);
47   }
48 
49   // Return the last sample from the last processed frame.
50   return ab.channels()[0][num_samples - 1];
51 }
52 
CreateAgc2FixedDigitalModeConfig(float fixed_gain_db)53 AudioProcessing::Config::GainController2 CreateAgc2FixedDigitalModeConfig(
54     float fixed_gain_db) {
55   AudioProcessing::Config::GainController2 config;
56   config.adaptive_digital.enabled = false;
57   config.fixed_digital.gain_db = fixed_gain_db;
58   // TODO(alessiob): Check why ASSERT_TRUE() below does not compile.
59   EXPECT_TRUE(GainController2::Validate(config));
60   return config;
61 }
62 
CreateAgc2FixedDigitalMode(float fixed_gain_db,size_t sample_rate_hz)63 std::unique_ptr<GainController2> CreateAgc2FixedDigitalMode(
64     float fixed_gain_db,
65     size_t sample_rate_hz) {
66   auto agc2 = std::make_unique<GainController2>();
67   agc2->ApplyConfig(CreateAgc2FixedDigitalModeConfig(fixed_gain_db));
68   agc2->Initialize(sample_rate_hz);
69   return agc2;
70 }
71 
GainDbAfterProcessingFile(GainController2 & gain_controller,int max_duration_ms)72 float GainDbAfterProcessingFile(GainController2& gain_controller,
73                                 int max_duration_ms) {
74   // Set up an AudioBuffer to be filled from the speech file.
75   constexpr size_t kStereo = 2u;
76   const StreamConfig capture_config(AudioProcessing::kSampleRate48kHz, kStereo,
77                                     false);
78   AudioBuffer ab(capture_config.sample_rate_hz(), capture_config.num_channels(),
79                  capture_config.sample_rate_hz(), capture_config.num_channels(),
80                  capture_config.sample_rate_hz(),
81                  capture_config.num_channels());
82   test::InputAudioFile capture_file(
83       test::GetApmCaptureTestVectorFileName(AudioProcessing::kSampleRate48kHz));
84   std::vector<float> capture_input(capture_config.num_frames() *
85                                    capture_config.num_channels());
86 
87   // Process the input file which must be long enough to cover
88   // `max_duration_ms`.
89   RTC_DCHECK_GT(max_duration_ms, 0);
90   const int num_frames = rtc::CheckedDivExact(max_duration_ms, 10);
91   for (int i = 0; i < num_frames; ++i) {
92     ReadFloatSamplesFromStereoFile(capture_config.num_frames(),
93                                    capture_config.num_channels(), &capture_file,
94                                    capture_input);
95     test::CopyVectorToAudioBuffer(capture_config, capture_input, &ab);
96     gain_controller.Process(&ab);
97   }
98 
99   // Send in a last frame with minimum dBFS level.
100   constexpr float sample_value = 1.f;
101   SetAudioBufferSamples(sample_value, &ab);
102   gain_controller.Process(&ab);
103   // Measure the RMS level after processing.
104   float rms = 0.0f;
105   for (size_t i = 0; i < capture_config.num_frames(); ++i) {
106     rms += ab.channels()[0][i] * ab.channels()[0][i];
107   }
108   // Return the applied gain in dB.
109   return 20.0f * std::log10(std::sqrt(rms / capture_config.num_frames()));
110 }
111 
112 }  // namespace
113 
TEST(GainController2,CheckDefaultConfig)114 TEST(GainController2, CheckDefaultConfig) {
115   AudioProcessing::Config::GainController2 config;
116   EXPECT_TRUE(GainController2::Validate(config));
117 }
118 
TEST(GainController2,CheckFixedDigitalConfig)119 TEST(GainController2, CheckFixedDigitalConfig) {
120   AudioProcessing::Config::GainController2 config;
121   // Attenuation is not allowed.
122   config.fixed_digital.gain_db = -5.f;
123   EXPECT_FALSE(GainController2::Validate(config));
124   // No gain is allowed.
125   config.fixed_digital.gain_db = 0.f;
126   EXPECT_TRUE(GainController2::Validate(config));
127   // Positive gain is allowed.
128   config.fixed_digital.gain_db = 15.f;
129   EXPECT_TRUE(GainController2::Validate(config));
130 }
131 
TEST(GainController2,CheckAdaptiveDigitalVadProbabilityAttackConfig)132 TEST(GainController2, CheckAdaptiveDigitalVadProbabilityAttackConfig) {
133   AudioProcessing::Config::GainController2 config;
134   // Reject invalid attack.
135   config.adaptive_digital.vad_probability_attack = -123.f;
136   EXPECT_FALSE(GainController2::Validate(config));
137   config.adaptive_digital.vad_probability_attack = 0.f;
138   EXPECT_FALSE(GainController2::Validate(config));
139   config.adaptive_digital.vad_probability_attack = 42.f;
140   EXPECT_FALSE(GainController2::Validate(config));
141   // Accept valid attack.
142   config.adaptive_digital.vad_probability_attack = 0.1f;
143   EXPECT_TRUE(GainController2::Validate(config));
144   config.adaptive_digital.vad_probability_attack = 1.f;
145   EXPECT_TRUE(GainController2::Validate(config));
146 }
147 
TEST(GainController2,CheckAdaptiveDigitalLevelEstimatorSpeechFramesThresholdConfig)148 TEST(GainController2,
149      CheckAdaptiveDigitalLevelEstimatorSpeechFramesThresholdConfig) {
150   AudioProcessing::Config::GainController2 config;
151   config.adaptive_digital.level_estimator_adjacent_speech_frames_threshold = 0;
152   EXPECT_FALSE(GainController2::Validate(config));
153   config.adaptive_digital.level_estimator_adjacent_speech_frames_threshold = 1;
154   EXPECT_TRUE(GainController2::Validate(config));
155   config.adaptive_digital.level_estimator_adjacent_speech_frames_threshold = 7;
156   EXPECT_TRUE(GainController2::Validate(config));
157 }
158 
TEST(GainController2,CheckAdaptiveDigitalInitialSaturationMarginConfig)159 TEST(GainController2, CheckAdaptiveDigitalInitialSaturationMarginConfig) {
160   AudioProcessing::Config::GainController2 config;
161   config.adaptive_digital.initial_saturation_margin_db = -1.f;
162   EXPECT_FALSE(GainController2::Validate(config));
163   config.adaptive_digital.initial_saturation_margin_db = 0.f;
164   EXPECT_TRUE(GainController2::Validate(config));
165   config.adaptive_digital.initial_saturation_margin_db = 50.f;
166   EXPECT_TRUE(GainController2::Validate(config));
167 }
168 
TEST(GainController2,CheckAdaptiveDigitalExtraSaturationMarginConfig)169 TEST(GainController2, CheckAdaptiveDigitalExtraSaturationMarginConfig) {
170   AudioProcessing::Config::GainController2 config;
171   config.adaptive_digital.extra_saturation_margin_db = -1.f;
172   EXPECT_FALSE(GainController2::Validate(config));
173   config.adaptive_digital.extra_saturation_margin_db = 0.f;
174   EXPECT_TRUE(GainController2::Validate(config));
175   config.adaptive_digital.extra_saturation_margin_db = 50.f;
176   EXPECT_TRUE(GainController2::Validate(config));
177 }
178 
TEST(GainController2,CheckAdaptiveDigitalGainApplierSpeechFramesThresholdConfig)179 TEST(GainController2,
180      CheckAdaptiveDigitalGainApplierSpeechFramesThresholdConfig) {
181   AudioProcessing::Config::GainController2 config;
182   config.adaptive_digital.gain_applier_adjacent_speech_frames_threshold = 0;
183   EXPECT_FALSE(GainController2::Validate(config));
184   config.adaptive_digital.gain_applier_adjacent_speech_frames_threshold = 1;
185   EXPECT_TRUE(GainController2::Validate(config));
186   config.adaptive_digital.gain_applier_adjacent_speech_frames_threshold = 7;
187   EXPECT_TRUE(GainController2::Validate(config));
188 }
189 
TEST(GainController2,CheckAdaptiveDigitalMaxGainChangeSpeedConfig)190 TEST(GainController2, CheckAdaptiveDigitalMaxGainChangeSpeedConfig) {
191   AudioProcessing::Config::GainController2 config;
192   config.adaptive_digital.max_gain_change_db_per_second = -1.f;
193   EXPECT_FALSE(GainController2::Validate(config));
194   config.adaptive_digital.max_gain_change_db_per_second = 0.f;
195   EXPECT_FALSE(GainController2::Validate(config));
196   config.adaptive_digital.max_gain_change_db_per_second = 5.f;
197   EXPECT_TRUE(GainController2::Validate(config));
198 }
199 
TEST(GainController2,CheckAdaptiveDigitalMaxOutputNoiseLevelConfig)200 TEST(GainController2, CheckAdaptiveDigitalMaxOutputNoiseLevelConfig) {
201   AudioProcessing::Config::GainController2 config;
202   config.adaptive_digital.max_output_noise_level_dbfs = 5.f;
203   EXPECT_FALSE(GainController2::Validate(config));
204   config.adaptive_digital.max_output_noise_level_dbfs = 0.f;
205   EXPECT_TRUE(GainController2::Validate(config));
206   config.adaptive_digital.max_output_noise_level_dbfs = -5.f;
207   EXPECT_TRUE(GainController2::Validate(config));
208 }
209 
210 // Checks that the default config is applied.
TEST(GainController2,ApplyDefaultConfig)211 TEST(GainController2, ApplyDefaultConfig) {
212   auto gain_controller2 = std::make_unique<GainController2>();
213   AudioProcessing::Config::GainController2 config;
214   gain_controller2->ApplyConfig(config);
215 }
216 
TEST(GainController2FixedDigital,GainShouldChangeOnSetGain)217 TEST(GainController2FixedDigital, GainShouldChangeOnSetGain) {
218   constexpr float kInputLevel = 1000.f;
219   constexpr size_t kNumFrames = 5;
220   constexpr size_t kSampleRateHz = 8000;
221   constexpr float kGain0Db = 0.f;
222   constexpr float kGain20Db = 20.f;
223 
224   auto agc2_fixed = CreateAgc2FixedDigitalMode(kGain0Db, kSampleRateHz);
225 
226   // Signal level is unchanged with 0 db gain.
227   EXPECT_FLOAT_EQ(RunAgc2WithConstantInput(agc2_fixed.get(), kInputLevel,
228                                            kNumFrames, kSampleRateHz),
229                   kInputLevel);
230 
231   // +20 db should increase signal by a factor of 10.
232   agc2_fixed->ApplyConfig(CreateAgc2FixedDigitalModeConfig(kGain20Db));
233   EXPECT_FLOAT_EQ(RunAgc2WithConstantInput(agc2_fixed.get(), kInputLevel,
234                                            kNumFrames, kSampleRateHz),
235                   kInputLevel * 10);
236 }
237 
TEST(GainController2FixedDigital,ChangeFixedGainShouldBeFastAndTimeInvariant)238 TEST(GainController2FixedDigital, ChangeFixedGainShouldBeFastAndTimeInvariant) {
239   // Number of frames required for the fixed gain controller to adapt on the
240   // input signal when the gain changes.
241   constexpr size_t kNumFrames = 5;
242 
243   constexpr float kInputLevel = 1000.f;
244   constexpr size_t kSampleRateHz = 8000;
245   constexpr float kGainDbLow = 0.f;
246   constexpr float kGainDbHigh = 25.f;
247   static_assert(kGainDbLow < kGainDbHigh, "");
248 
249   auto agc2_fixed = CreateAgc2FixedDigitalMode(kGainDbLow, kSampleRateHz);
250 
251   // Start with a lower gain.
252   const float output_level_pre = RunAgc2WithConstantInput(
253       agc2_fixed.get(), kInputLevel, kNumFrames, kSampleRateHz);
254 
255   // Increase gain.
256   agc2_fixed->ApplyConfig(CreateAgc2FixedDigitalModeConfig(kGainDbHigh));
257   static_cast<void>(RunAgc2WithConstantInput(agc2_fixed.get(), kInputLevel,
258                                              kNumFrames, kSampleRateHz));
259 
260   // Back to the lower gain.
261   agc2_fixed->ApplyConfig(CreateAgc2FixedDigitalModeConfig(kGainDbLow));
262   const float output_level_post = RunAgc2WithConstantInput(
263       agc2_fixed.get(), kInputLevel, kNumFrames, kSampleRateHz);
264 
265   EXPECT_EQ(output_level_pre, output_level_post);
266 }
267 
268 struct FixedDigitalTestParams {
FixedDigitalTestParamswebrtc::test::FixedDigitalTestParams269   FixedDigitalTestParams(float gain_db_min,
270                          float gain_db_max,
271                          size_t sample_rate,
272                          bool saturation_expected)
273       : gain_db_min(gain_db_min),
274         gain_db_max(gain_db_max),
275         sample_rate(sample_rate),
276         saturation_expected(saturation_expected) {}
277   float gain_db_min;
278   float gain_db_max;
279   size_t sample_rate;
280   bool saturation_expected;
281 };
282 
283 class FixedDigitalTest
284     : public ::testing::Test,
285       public ::testing::WithParamInterface<FixedDigitalTestParams> {};
286 
TEST_P(FixedDigitalTest,CheckSaturationBehaviorWithLimiter)287 TEST_P(FixedDigitalTest, CheckSaturationBehaviorWithLimiter) {
288   const float kInputLevel = 32767.f;
289   const size_t kNumFrames = 5;
290 
291   const auto params = GetParam();
292 
293   const auto gains_db =
294       test::LinSpace(params.gain_db_min, params.gain_db_max, 10);
295   for (const auto gain_db : gains_db) {
296     SCOPED_TRACE(std::to_string(gain_db));
297     auto agc2_fixed = CreateAgc2FixedDigitalMode(gain_db, params.sample_rate);
298     const float processed_sample = RunAgc2WithConstantInput(
299         agc2_fixed.get(), kInputLevel, kNumFrames, params.sample_rate);
300     if (params.saturation_expected) {
301       EXPECT_FLOAT_EQ(processed_sample, 32767.f);
302     } else {
303       EXPECT_LT(processed_sample, 32767.f);
304     }
305   }
306 }
307 
308 static_assert(test::kLimiterMaxInputLevelDbFs < 10, "");
309 INSTANTIATE_TEST_SUITE_P(
310     GainController2,
311     FixedDigitalTest,
312     ::testing::Values(
313         // When gain < |test::kLimiterMaxInputLevelDbFs|, the limiter will not
314         // saturate the signal (at any sample rate).
315         FixedDigitalTestParams(0.1f,
316                                test::kLimiterMaxInputLevelDbFs - 0.01f,
317                                8000,
318                                false),
319         FixedDigitalTestParams(0.1,
320                                test::kLimiterMaxInputLevelDbFs - 0.01f,
321                                48000,
322                                false),
323         // When gain > |test::kLimiterMaxInputLevelDbFs|, the limiter will
324         // saturate the signal (at any sample rate).
325         FixedDigitalTestParams(test::kLimiterMaxInputLevelDbFs + 0.01f,
326                                10.f,
327                                8000,
328                                true),
329         FixedDigitalTestParams(test::kLimiterMaxInputLevelDbFs + 0.01f,
330                                10.f,
331                                48000,
332                                true)));
333 
334 // Checks that the gain applied at the end of a PCM samples file is close to the
335 // expected value.
TEST(GainController2,CheckGainAdaptiveDigital)336 TEST(GainController2, CheckGainAdaptiveDigital) {
337   constexpr float kExpectedGainDb = 4.3f;
338   constexpr float kToleranceDb = 0.5f;
339   GainController2 gain_controller2;
340   gain_controller2.Initialize(AudioProcessing::kSampleRate48kHz);
341   AudioProcessing::Config::GainController2 config;
342   config.fixed_digital.gain_db = 0.f;
343   config.adaptive_digital.enabled = true;
344   gain_controller2.ApplyConfig(config);
345   EXPECT_NEAR(
346       GainDbAfterProcessingFile(gain_controller2, /*max_duration_ms=*/2000),
347       kExpectedGainDb, kToleranceDb);
348 }
349 
350 }  // namespace test
351 }  // namespace webrtc
352