| /* | |
| * Copyright (c) 2013 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 "modules/audio_processing/agc/agc_manager_direct.h" | |
| #include <algorithm> | |
| #include <cmath> | |
| #include <cstddef> | |
| #include <cstdint> | |
| #include <fstream> | |
| #include <ios> | |
| #include <limits> | |
| #include <memory> | |
| #include <optional> | |
| #include <string> | |
| #include <tuple> | |
| #include <vector> | |
| #include "api/audio/audio_processing.h" | |
| #include "api/environment/environment.h" | |
| #include "api/environment/environment_factory.h" | |
| #include "modules/audio_processing/agc/agc.h" | |
| #include "modules/audio_processing/agc/gain_control.h" | |
| #include "modules/audio_processing/agc/mock_agc.h" | |
| #include "modules/audio_processing/audio_buffer.h" | |
| #include "rtc_base/checks.h" | |
| #include "rtc_base/numerics/safe_minmax.h" | |
| #include "rtc_base/strings/string_builder.h" | |
| #include "test/create_test_field_trials.h" | |
| #include "test/gmock.h" | |
| #include "test/gtest.h" | |
| #include "test/testsupport/file_utils.h" | |
| using ::testing::_; | |
| using ::testing::AtLeast; | |
| using ::testing::DoAll; | |
| using ::testing::Return; | |
| using ::testing::SetArgPointee; | |
| namespace webrtc { | |
| namespace { | |
| constexpr int kSampleRateHz = 32000; | |
| constexpr int kNumChannels = 1; | |
| constexpr int kInitialInputVolume = 128; | |
| constexpr int kClippedMin = 165; // Arbitrary, but different from the default. | |
| constexpr float kAboveClippedThreshold = 0.2f; | |
| constexpr int kMinMicLevel = 12; | |
| constexpr int kClippedLevelStep = 15; | |
| constexpr float kClippedRatioThreshold = 0.1f; | |
| constexpr int kClippedWaitFrames = 300; | |
| constexpr float kLowSpeechProbability = 0.1f; | |
| constexpr float kHighSpeechProbability = 0.7f; | |
| constexpr float kSpeechLevelDbfs = -25.0f; | |
| constexpr float kMinSample = std::numeric_limits<int16_t>::min(); | |
| constexpr float kMaxSample = std::numeric_limits<int16_t>::max(); | |
| using AnalogAgcConfig = | |
| AudioProcessing::Config::GainController1::AnalogGainController; | |
| using ClippingPredictorConfig = AudioProcessing::Config::GainController1:: | |
| AnalogGainController::ClippingPredictor; | |
| constexpr AnalogAgcConfig kDefaultAnalogConfig{}; | |
| class MockGainControl : public GainControl { | |
| public: | |
| ~MockGainControl() override {} | |
| MOCK_METHOD(int, set_stream_analog_level, (int level), (override)); | |
| MOCK_METHOD(int, stream_analog_level, (), (const, override)); | |
| MOCK_METHOD(int, set_mode, (Mode mode), (override)); | |
| MOCK_METHOD(Mode, mode, (), (const, override)); | |
| MOCK_METHOD(int, set_target_level_dbfs, (int level), (override)); | |
| MOCK_METHOD(int, target_level_dbfs, (), (const, override)); | |
| MOCK_METHOD(int, set_compression_gain_db, (int gain), (override)); | |
| MOCK_METHOD(int, compression_gain_db, (), (const, override)); | |
| MOCK_METHOD(int, enable_limiter, (bool enable), (override)); | |
| MOCK_METHOD(bool, is_limiter_enabled, (), (const, override)); | |
| MOCK_METHOD(int, | |
| set_analog_level_limits, | |
| (int minimum, int maximum), | |
| (override)); | |
| MOCK_METHOD(int, analog_level_minimum, (), (const, override)); | |
| MOCK_METHOD(int, analog_level_maximum, (), (const, override)); | |
| MOCK_METHOD(bool, stream_is_saturated, (), (const, override)); | |
| }; | |
| // Construction parameters that tests may explicitely specify. | |
| struct AgcManagerDirectTestParams { | |
| std::string field_trials; | |
| int clipped_level_min = kClippedMin; | |
| bool enable_digital_adaptive = false; | |
| int clipped_level_step = kClippedLevelStep; | |
| float clipped_ratio_threshold = kClippedRatioThreshold; | |
| int clipped_wait_frames = kClippedWaitFrames; | |
| AnalogAgcConfig::ClippingPredictor clipping_predictor; | |
| }; | |
| std::unique_ptr<AgcManagerDirect> CreateAgcManagerDirect( | |
| AgcManagerDirectTestParams p = {}) { | |
| auto manager = std::make_unique<AgcManagerDirect>( | |
| CreateEnvironment(CreateTestFieldTrialsPtr(p.field_trials)), kNumChannels, | |
| AnalogAgcConfig{.startup_min_volume = kInitialInputVolume, | |
| .clipped_level_min = p.clipped_level_min, | |
| .enable_digital_adaptive = p.enable_digital_adaptive, | |
| .clipped_level_step = p.clipped_level_step, | |
| .clipped_ratio_threshold = p.clipped_ratio_threshold, | |
| .clipped_wait_frames = p.clipped_wait_frames, | |
| .clipping_predictor = p.clipping_predictor}); | |
| manager->Initialize(); | |
| manager->set_stream_analog_level(kInitialInputVolume); | |
| return manager; | |
| } | |
| // Deprecated. | |
| // TODO(bugs.webrtc.org/7494): Delete this helper, use | |
| // `AgcManagerDirectTestHelper::CallAgcSequence()` instead. | |
| // Calls `AnalyzePreProcess()` on `manager` `num_calls` times. `peak_ratio` is a | |
| // value in [0, 1] which determines the amplitude of the samples (1 maps to full | |
| // scale). The first half of the calls is made on frames which are half filled | |
| // with zeros in order to simulate a signal with different crest factors. | |
| void CallPreProcessAudioBuffer(int num_calls, | |
| float peak_ratio, | |
| AgcManagerDirect& manager) { | |
| RTC_DCHECK_LE(peak_ratio, 1.0f); | |
| AudioBuffer audio_buffer(kSampleRateHz, kNumChannels, kSampleRateHz, | |
| kNumChannels, kSampleRateHz, kNumChannels); | |
| const int num_channels = audio_buffer.num_channels(); | |
| const int num_frames = audio_buffer.num_frames(); | |
| // Make half of the calls with half zeroed frames. | |
| for (int ch = 0; ch < num_channels; ++ch) { | |
| // 50% of the samples in one frame are zero. | |
| for (int i = 0; i < num_frames; i += 2) { | |
| audio_buffer.channels()[ch][i] = peak_ratio * 32767.0f; | |
| audio_buffer.channels()[ch][i + 1] = 0.0f; | |
| } | |
| } | |
| for (int n = 0; n < num_calls / 2; ++n) { | |
| manager.AnalyzePreProcess(audio_buffer); | |
| } | |
| // Make the remaining half of the calls with frames whose samples are all set. | |
| for (int ch = 0; ch < num_channels; ++ch) { | |
| for (int i = 0; i < num_frames; ++i) { | |
| audio_buffer.channels()[ch][i] = peak_ratio * 32767.0f; | |
| } | |
| } | |
| for (int n = 0; n < num_calls - num_calls / 2; ++n) { | |
| manager.AnalyzePreProcess(audio_buffer); | |
| } | |
| } | |
| constexpr char kMinMicLevelFieldTrial[] = | |
| "WebRTC-Audio-2ndAgcMinMicLevelExperiment"; | |
| std::string GetAgcMinMicLevelExperimentFieldTrial(const std::string& value) { | |
| char field_trial_buffer[64]; | |
| SimpleStringBuilder builder(field_trial_buffer); | |
| builder << kMinMicLevelFieldTrial << "/" << value << "/"; | |
| return builder.str(); | |
| } | |
| std::string GetAgcMinMicLevelExperimentFieldTrialEnabled( | |
| int enabled_value, | |
| const std::string& suffix = "") { | |
| RTC_DCHECK_GE(enabled_value, 0); | |
| RTC_DCHECK_LE(enabled_value, 255); | |
| char field_trial_buffer[64]; | |
| SimpleStringBuilder builder(field_trial_buffer); | |
| builder << kMinMicLevelFieldTrial << "/Enabled-" << enabled_value << suffix | |
| << "/"; | |
| return builder.str(); | |
| } | |
| std::string GetAgcMinMicLevelExperimentFieldTrial( | |
| std::optional<int> min_mic_level) { | |
| if (min_mic_level.has_value()) { | |
| return GetAgcMinMicLevelExperimentFieldTrialEnabled(*min_mic_level); | |
| } | |
| return GetAgcMinMicLevelExperimentFieldTrial("Disabled"); | |
| } | |
| // (Over)writes `samples_value` for the samples in `audio_buffer`. | |
| // When `clipped_ratio`, a value in [0, 1], is greater than 0, the corresponding | |
| // fraction of the frame is set to a full scale value to simulate clipping. | |
| void WriteAudioBufferSamples(float samples_value, | |
| float clipped_ratio, | |
| AudioBuffer& audio_buffer) { | |
| RTC_DCHECK_GE(samples_value, kMinSample); | |
| RTC_DCHECK_LE(samples_value, kMaxSample); | |
| RTC_DCHECK_GE(clipped_ratio, 0.0f); | |
| RTC_DCHECK_LE(clipped_ratio, 1.0f); | |
| int num_channels = audio_buffer.num_channels(); | |
| int num_samples = audio_buffer.num_frames(); | |
| int num_clipping_samples = clipped_ratio * num_samples; | |
| for (int ch = 0; ch < num_channels; ++ch) { | |
| int i = 0; | |
| for (; i < num_clipping_samples; ++i) { | |
| audio_buffer.channels()[ch][i] = 32767.0f; | |
| } | |
| for (; i < num_samples; ++i) { | |
| audio_buffer.channels()[ch][i] = samples_value; | |
| } | |
| } | |
| } | |
| // Deprecated. | |
| // TODO(bugs.webrtc.org/7494): Delete this helper, use | |
| // `AgcManagerDirectTestHelper::CallAgcSequence()` instead. | |
| void CallPreProcessAndProcess(int num_calls, | |
| const AudioBuffer& audio_buffer, | |
| std::optional<float> speech_probability_override, | |
| std::optional<float> speech_level_override, | |
| AgcManagerDirect& manager) { | |
| for (int n = 0; n < num_calls; ++n) { | |
| manager.AnalyzePreProcess(audio_buffer); | |
| manager.Process(audio_buffer, speech_probability_override, | |
| speech_level_override); | |
| } | |
| } | |
| // Reads a given number of 10 ms chunks from a PCM file and feeds them to | |
| // `AgcManagerDirect`. | |
| class SpeechSamplesReader { | |
| private: | |
| // Recording properties. | |
| static constexpr int kPcmSampleRateHz = 16000; | |
| static constexpr int kPcmNumChannels = 1; | |
| static constexpr int kPcmBytesPerSamples = sizeof(int16_t); | |
| public: | |
| SpeechSamplesReader() | |
| : is_(test::ResourcePath("audio_processing/agc/agc_audio", "pcm"), | |
| std::ios::binary | std::ios::ate), | |
| audio_buffer_(kPcmSampleRateHz, | |
| kPcmNumChannels, | |
| kPcmSampleRateHz, | |
| kPcmNumChannels, | |
| kPcmSampleRateHz, | |
| kPcmNumChannels), | |
| buffer_(audio_buffer_.num_frames()), | |
| buffer_num_bytes_(buffer_.size() * kPcmBytesPerSamples) { | |
| RTC_CHECK(is_); | |
| } | |
| // Reads `num_frames` 10 ms frames from the beginning of the PCM file, applies | |
| // `gain_db` and feeds the frames into `agc` by calling `AnalyzePreProcess()` | |
| // and `Process()` for each frame. Reads the number of 10 ms frames available | |
| // in the PCM file if `num_frames` is too large - i.e., does not loop. | |
| void Feed(int num_frames, int gain_db, AgcManagerDirect& agc) { | |
| float gain = std::pow(10.0f, gain_db / 20.0f); // From dB to linear gain. | |
| is_.seekg(0, | |
| std::ifstream::beg); // Start from the beginning of the PCM file. | |
| // Read and feed frames. | |
| for (int i = 0; i < num_frames; ++i) { | |
| is_.read(reinterpret_cast<char*>(buffer_.data()), buffer_num_bytes_); | |
| if (is_.gcount() < buffer_num_bytes_) { | |
| // EOF reached. Stop. | |
| break; | |
| } | |
| // Apply gain and copy samples into `audio_buffer_`. | |
| std::transform(buffer_.begin(), buffer_.end(), | |
| audio_buffer_.channels()[0], [gain](int16_t v) -> float { | |
| return SafeClamp(static_cast<float>(v) * gain, | |
| kMinSample, kMaxSample); | |
| }); | |
| agc.AnalyzePreProcess(audio_buffer_); | |
| agc.Process(audio_buffer_); | |
| } | |
| } | |
| // Reads `num_frames` 10 ms frames from the beginning of the PCM file, applies | |
| // `gain_db` and feeds the frames into `agc` by calling `AnalyzePreProcess()` | |
| // and `Process()` for each frame. Reads the number of 10 ms frames available | |
| // in the PCM file if `num_frames` is too large - i.e., does not loop. | |
| // `speech_probability_override` and `speech_level_override` are passed to | |
| // `Process()` where they are used to override the `agc` RMS error if they | |
| // have a value. | |
| void Feed(int num_frames, | |
| int gain_db, | |
| std::optional<float> speech_probability_override, | |
| std::optional<float> speech_level_override, | |
| AgcManagerDirect& agc) { | |
| float gain = std::pow(10.0f, gain_db / 20.0f); // From dB to linear gain. | |
| is_.seekg(0, | |
| std::ifstream::beg); // Start from the beginning of the PCM file. | |
| // Read and feed frames. | |
| for (int i = 0; i < num_frames; ++i) { | |
| is_.read(reinterpret_cast<char*>(buffer_.data()), buffer_num_bytes_); | |
| if (is_.gcount() < buffer_num_bytes_) { | |
| // EOF reached. Stop. | |
| break; | |
| } | |
| // Apply gain and copy samples into `audio_buffer_`. | |
| std::transform(buffer_.begin(), buffer_.end(), | |
| audio_buffer_.channels()[0], [gain](int16_t v) -> float { | |
| return SafeClamp(static_cast<float>(v) * gain, | |
| kMinSample, kMaxSample); | |
| }); | |
| agc.AnalyzePreProcess(audio_buffer_); | |
| agc.Process(audio_buffer_, speech_probability_override, | |
| speech_level_override); | |
| } | |
| } | |
| private: | |
| std::ifstream is_; | |
| AudioBuffer audio_buffer_; | |
| std::vector<int16_t> buffer_; | |
| const std::streamsize buffer_num_bytes_; | |
| }; | |
| } // namespace | |
| // TODO(bugs.webrtc.org/12874): Use constexpr struct with designated | |
| // initializers once fixed. | |
| constexpr AnalogAgcConfig GetAnalogAgcTestConfig() { | |
| AnalogAgcConfig config; | |
| config.enabled = true; | |
| config.startup_min_volume = kInitialInputVolume; | |
| config.clipped_level_min = kClippedMin; | |
| config.enable_digital_adaptive = true; | |
| config.clipped_level_step = kClippedLevelStep; | |
| config.clipped_ratio_threshold = kClippedRatioThreshold; | |
| config.clipped_wait_frames = kClippedWaitFrames; | |
| config.clipping_predictor = kDefaultAnalogConfig.clipping_predictor; | |
| return config; | |
| } | |
| constexpr AnalogAgcConfig GetDisabledAnalogAgcConfig() { | |
| AnalogAgcConfig config = GetAnalogAgcTestConfig(); | |
| config.enabled = false; | |
| return config; | |
| } | |
| // Helper class that provides an `AgcManagerDirect` instance with an injected | |
| // `Agc` mock, an `AudioBuffer` instance and `CallAgcSequence()`, a helper | |
| // method that runs the `AgcManagerDirect` instance on the `AudioBuffer` one by | |
| // sticking to the API contract. | |
| class AgcManagerDirectTestHelper { | |
| public: | |
| // Ctor. Initializes `audio_buffer` with zeros. | |
| explicit AgcManagerDirectTestHelper(const Environment& env) | |
| : audio_buffer(kSampleRateHz, | |
| kNumChannels, | |
| kSampleRateHz, | |
| kNumChannels, | |
| kSampleRateHz, | |
| kNumChannels), | |
| mock_agc(new ::testing::NiceMock<MockAgc>()), | |
| manager(env, GetAnalogAgcTestConfig(), mock_agc) { | |
| manager.Initialize(); | |
| manager.SetupDigitalGainControl(mock_gain_control); | |
| WriteAudioBufferSamples(/*samples_value=*/0.0f, /*clipped_ratio=*/0.0f, | |
| audio_buffer); | |
| } | |
| // Calls the sequence of `AgcManagerDirect` methods according to the API | |
| // contract, namely: | |
| // - Sets the applied input volume; | |
| // - Uses `audio_buffer` to call `AnalyzePreProcess()` and `Process()`; | |
| // - Sets the digital compression gain, if specified, on the injected | |
| // `mock_agc`. Returns the recommended input volume. The RMS error from | |
| // AGC is replaced by an override value if `speech_probability_override` | |
| // and `speech_level_override` have a value. | |
| int CallAgcSequence(int applied_input_volume, | |
| std::optional<float> speech_probability_override, | |
| std::optional<float> speech_level_override) { | |
| manager.set_stream_analog_level(applied_input_volume); | |
| manager.AnalyzePreProcess(audio_buffer); | |
| manager.Process(audio_buffer, speech_probability_override, | |
| speech_level_override); | |
| std::optional<int> digital_gain = manager.GetDigitalComressionGain(); | |
| if (digital_gain) { | |
| mock_gain_control.set_compression_gain_db(*digital_gain); | |
| } | |
| return manager.recommended_analog_level(); | |
| } | |
| // Deprecated. | |
| // TODO(bugs.webrtc.org/7494): Let the caller write `audio_buffer` and use | |
| // `CallAgcSequence()`. The RMS error from AGC is replaced by an override | |
| // value if `speech_probability_override` and `speech_level_override` have | |
| // a value. | |
| void CallProcess(int num_calls, | |
| std::optional<float> speech_probability_override, | |
| std::optional<float> speech_level_override) { | |
| for (int i = 0; i < num_calls; ++i) { | |
| EXPECT_CALL(*mock_agc, Process(_)).WillOnce(Return()); | |
| manager.Process(audio_buffer, speech_probability_override, | |
| speech_level_override); | |
| std::optional<int> new_digital_gain = manager.GetDigitalComressionGain(); | |
| if (new_digital_gain) { | |
| mock_gain_control.set_compression_gain_db(*new_digital_gain); | |
| } | |
| } | |
| } | |
| // Deprecated. | |
| // TODO(bugs.webrtc.org/7494): Let the caller write `audio_buffer` and use | |
| // `CallAgcSequence()`. | |
| void CallPreProc(int num_calls, float clipped_ratio) { | |
| RTC_DCHECK_GE(clipped_ratio, 0.0f); | |
| RTC_DCHECK_LE(clipped_ratio, 1.0f); | |
| WriteAudioBufferSamples(/*samples_value=*/0.0f, clipped_ratio, | |
| audio_buffer); | |
| for (int i = 0; i < num_calls; ++i) { | |
| manager.AnalyzePreProcess(audio_buffer); | |
| } | |
| } | |
| // Deprecated. | |
| // TODO(bugs.webrtc.org/7494): Let the caller write `audio_buffer` and use | |
| // `CallAgcSequence()`. | |
| void CallPreProcForChangingAudio(int num_calls, float peak_ratio) { | |
| RTC_DCHECK_GE(peak_ratio, 0.0f); | |
| RTC_DCHECK_LE(peak_ratio, 1.0f); | |
| const float samples_value = peak_ratio * 32767.0f; | |
| // Make half of the calls on a frame where the samples alternate | |
| // `sample_values` and zeros. | |
| WriteAudioBufferSamples(samples_value, /*clipped_ratio=*/0.0f, | |
| audio_buffer); | |
| for (size_t ch = 0; ch < audio_buffer.num_channels(); ++ch) { | |
| for (size_t k = 1; k < audio_buffer.num_frames(); k += 2) { | |
| audio_buffer.channels()[ch][k] = 0.0f; | |
| } | |
| } | |
| for (int i = 0; i < num_calls / 2; ++i) { | |
| manager.AnalyzePreProcess(audio_buffer); | |
| } | |
| // Make half of thecalls on a frame where all the samples equal | |
| // `sample_values`. | |
| WriteAudioBufferSamples(samples_value, /*clipped_ratio=*/0.0f, | |
| audio_buffer); | |
| for (int i = 0; i < num_calls - num_calls / 2; ++i) { | |
| manager.AnalyzePreProcess(audio_buffer); | |
| } | |
| } | |
| AudioBuffer audio_buffer; | |
| MockAgc* mock_agc; | |
| AgcManagerDirect manager; | |
| MockGainControl mock_gain_control; | |
| }; | |
| class AgcManagerDirectParametrizedTest | |
| : public ::testing::TestWithParam<std::tuple<std::optional<int>, bool>> { | |
| protected: | |
| AgcManagerDirectParametrizedTest() | |
| : env_(CreateEnvironment(CreateTestFieldTrialsPtr( | |
| GetAgcMinMicLevelExperimentFieldTrial(std::get<0>(GetParam()))))) {} | |
| bool IsMinMicLevelOverridden() const { | |
| return std::get<0>(GetParam()).has_value(); | |
| } | |
| int GetMinMicLevel() const { | |
| return std::get<0>(GetParam()).value_or(kMinMicLevel); | |
| } | |
| bool IsRmsErrorOverridden() const { return std::get<1>(GetParam()); } | |
| std::optional<float> GetOverrideOrEmpty(float value) const { | |
| return IsRmsErrorOverridden() ? std::optional<float>(value) : std::nullopt; | |
| } | |
| const Environment env_; | |
| }; | |
| INSTANTIATE_TEST_SUITE_P( | |
| , | |
| AgcManagerDirectParametrizedTest, | |
| ::testing::Combine(testing::Values(std::nullopt, 12, 20), testing::Bool())); | |
| // Checks that when the analog controller is disabled, no downward adaptation | |
| // takes place. | |
| // TODO(webrtc:7494): Revisit the test after moving the number of override wait | |
| // frames to AMP config. The test passes but internally the gain update timing | |
| // differs. | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| DisabledAnalogAgcDoesNotAdaptDownwards) { | |
| AgcManagerDirect manager_no_analog_agc(env_, kNumChannels, | |
| GetDisabledAnalogAgcConfig()); | |
| manager_no_analog_agc.Initialize(); | |
| AgcManagerDirect manager_with_analog_agc(env_, kNumChannels, | |
| GetAnalogAgcTestConfig()); | |
| manager_with_analog_agc.Initialize(); | |
| AudioBuffer audio_buffer(kSampleRateHz, kNumChannels, kSampleRateHz, | |
| kNumChannels, kSampleRateHz, kNumChannels); | |
| constexpr int kAnalogLevel = 250; | |
| static_assert(kAnalogLevel > kInitialInputVolume, "Increase `kAnalogLevel`."); | |
| manager_no_analog_agc.set_stream_analog_level(kAnalogLevel); | |
| manager_with_analog_agc.set_stream_analog_level(kAnalogLevel); | |
| // Make a first call with input that doesn't clip in order to let the | |
| // controller read the input volume. That is needed because clipping input | |
| // causes the controller to stay in idle state for | |
| // `AnalogAgcConfig::clipped_wait_frames` frames. | |
| WriteAudioBufferSamples(/*samples_value=*/0.0f, /*clipped_ratio=*/0.0f, | |
| audio_buffer); | |
| manager_no_analog_agc.AnalyzePreProcess(audio_buffer); | |
| manager_with_analog_agc.AnalyzePreProcess(audio_buffer); | |
| manager_no_analog_agc.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-18.0f)); | |
| manager_with_analog_agc.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-18.0f)); | |
| // Feed clipping input to trigger a downward adapation of the analog level. | |
| WriteAudioBufferSamples(/*samples_value=*/0.0f, /*clipped_ratio=*/0.2f, | |
| audio_buffer); | |
| manager_no_analog_agc.AnalyzePreProcess(audio_buffer); | |
| manager_with_analog_agc.AnalyzePreProcess(audio_buffer); | |
| manager_no_analog_agc.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-10.0f)); | |
| manager_with_analog_agc.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-10.0f)); | |
| // Check that no adaptation occurs when the analog controller is disabled | |
| // and make sure that the test triggers a downward adaptation otherwise. | |
| EXPECT_EQ(manager_no_analog_agc.recommended_analog_level(), kAnalogLevel); | |
| ASSERT_LT(manager_with_analog_agc.recommended_analog_level(), kAnalogLevel); | |
| } | |
| // Checks that when the analog controller is disabled, no upward adaptation | |
| // takes place. | |
| // TODO(webrtc:7494): Revisit the test after moving the number of override wait | |
| // frames to APM config. The test passes but internally the gain update timing | |
| // differs. | |
| TEST_P(AgcManagerDirectParametrizedTest, DisabledAnalogAgcDoesNotAdaptUpwards) { | |
| AgcManagerDirect manager_no_analog_agc(env_, kNumChannels, | |
| GetDisabledAnalogAgcConfig()); | |
| manager_no_analog_agc.Initialize(); | |
| AgcManagerDirect manager_with_analog_agc(env_, kNumChannels, | |
| GetAnalogAgcTestConfig()); | |
| manager_with_analog_agc.Initialize(); | |
| constexpr int kAnalogLevel = kInitialInputVolume; | |
| manager_no_analog_agc.set_stream_analog_level(kAnalogLevel); | |
| manager_with_analog_agc.set_stream_analog_level(kAnalogLevel); | |
| // Feed speech with low energy to trigger an upward adapation of the analog | |
| // level. | |
| constexpr int kNumFrames = 125; | |
| constexpr int kGainDb = -20; | |
| SpeechSamplesReader reader; | |
| reader.Feed(kNumFrames, kGainDb, GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-42.0f), manager_no_analog_agc); | |
| reader.Feed(kNumFrames, kGainDb, GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-42.0f), manager_with_analog_agc); | |
| // Check that no adaptation occurs when the analog controller is disabled | |
| // and make sure that the test triggers an upward adaptation otherwise. | |
| EXPECT_EQ(manager_no_analog_agc.recommended_analog_level(), kAnalogLevel); | |
| ASSERT_GT(manager_with_analog_agc.recommended_analog_level(), kAnalogLevel); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| StartupMinVolumeConfigurationIsRespected) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_EQ(kInitialInputVolume, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, MicVolumeResponseToRmsError) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Compressor default; no residual error. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(5), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-23.0f)); | |
| // Inside the compressor's window; no change of volume. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(10), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-28.0f)); | |
| // Above the compressor's window; volume should be increased. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-29.0f)); | |
| EXPECT_EQ(130, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(20), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-38.0f)); | |
| EXPECT_EQ(168, helper.manager.recommended_analog_level()); | |
| // Inside the compressor's window; no change of volume. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(5), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-23.0f)); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(0), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-18.0f)); | |
| // Below the compressor's window; volume should be decreased. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(167, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(163, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-9), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-9.0f)); | |
| EXPECT_EQ(129, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, MicVolumeIsLimited) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Maximum upwards change is limited. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(183, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(243, helper.manager.recommended_analog_level()); | |
| // Won't go higher than the maximum. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(254, helper.manager.recommended_analog_level()); | |
| // Maximum downwards change is limited. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(194, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(137, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(88, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(54, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(33, helper.manager.recommended_analog_level()); | |
| // Won't go lower than the minimum. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(std::max(18, GetMinMicLevel()), | |
| helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(22.0f)); | |
| EXPECT_EQ(std::max(12, GetMinMicLevel()), | |
| helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, CompressorStepsTowardsTarget) { | |
| constexpr std::optional<float> kNoOverride = std::nullopt; | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Compressor default; no call to set_compression_gain_db. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(5), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-23.0f)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| // The mock `GetRmsErrorDb()` returns false; mimic this by passing | |
| // std::nullopt as an override. | |
| helper.CallProcess(/*num_calls=*/19, kNoOverride, kNoOverride); | |
| // Moves slowly upwards. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(9), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-27.0f)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/18, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(8)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/19, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(9)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| // Moves slowly downward, then reverses before reaching the original target. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(5), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-23.0f)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/18, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(8)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(9), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-27.0f)); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/18, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(9)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, CompressorErrorIsDeemphasized) { | |
| constexpr std::optional<float> kNoOverride = std::nullopt; | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(10), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-28.0f)); | |
| // The mock `GetRmsErrorDb()` returns false; mimic this by passing | |
| // std::nullopt as an override. | |
| helper.CallProcess(/*num_calls=*/18, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(8)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(9)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(0), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-18.0f)); | |
| helper.CallProcess(/*num_calls=*/18, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(8)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(7)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(6)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(_)).Times(0); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, CompressorReachesMaximum) { | |
| constexpr std::optional<float> kNoOverride = std::nullopt; | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(10), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(10), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(10), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(10), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| helper.CallProcess(/*num_calls=*/4, speech_probability_override, | |
| GetOverrideOrEmpty(-28.0f)); | |
| // The mock `GetRmsErrorDb()` returns false; mimic this by passing | |
| // std::nullopt as an override. | |
| helper.CallProcess(/*num_calls=*/15, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(8)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(9)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(10)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(11)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(12)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, CompressorReachesMinimum) { | |
| constexpr std::optional<float> kNoOverride = std::nullopt; | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(0), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(0), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(0), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(0), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| helper.CallProcess(/*num_calls=*/4, speech_probability_override, | |
| GetOverrideOrEmpty(-18.0f)); | |
| // The mock `GetRmsErrorDb()` returns false; mimic this by passing | |
| // std::nullopt as an override. | |
| helper.CallProcess(/*num_calls=*/15, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(6)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(5)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(4)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(3)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(2)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, NoActionWhileMuted) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| helper.manager.HandleCaptureOutputUsedChange(false); | |
| helper.manager.Process(helper.audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| std::optional<int> new_digital_gain = | |
| helper.manager.GetDigitalComressionGain(); | |
| if (new_digital_gain) { | |
| helper.mock_gain_control.set_compression_gain_db(*new_digital_gain); | |
| } | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, UnmutingChecksVolumeWithoutRaising) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| helper.manager.HandleCaptureOutputUsedChange(false); | |
| helper.manager.HandleCaptureOutputUsedChange(true); | |
| constexpr int kInputVolume = 127; | |
| helper.manager.set_stream_analog_level(kInputVolume); | |
| EXPECT_CALL(*helper.mock_agc, Reset()); | |
| // SetMicVolume should not be called. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)).WillOnce(Return(false)); | |
| helper.CallProcess(/*num_calls=*/1, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_EQ(127, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, UnmutingRaisesTooLowVolume) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| helper.manager.HandleCaptureOutputUsedChange(false); | |
| helper.manager.HandleCaptureOutputUsedChange(true); | |
| constexpr int kInputVolume = 11; | |
| helper.manager.set_stream_analog_level(kInputVolume); | |
| EXPECT_CALL(*helper.mock_agc, Reset()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)).WillOnce(Return(false)); | |
| helper.CallProcess(/*num_calls=*/1, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_EQ(GetMinMicLevel(), helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| ManualLevelChangeResultsInNoSetMicCall) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Change outside of compressor's range, which would normally trigger a call | |
| // to `SetMicVolume()`. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))); | |
| // When the analog volume changes, the gain controller is reset. | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| // GetMicVolume returns a value outside of the quantization slack, indicating | |
| // a manual volume change. | |
| ASSERT_NE(helper.manager.recommended_analog_level(), 154); | |
| helper.manager.set_stream_analog_level(154); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-29.0f)); | |
| EXPECT_EQ(154, helper.manager.recommended_analog_level()); | |
| // Do the same thing, except downwards now. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.manager.set_stream_analog_level(100); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(100, helper.manager.recommended_analog_level()); | |
| // And finally verify the AGC continues working without a manual change. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(99, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| RecoveryAfterManualLevelChangeFromMax) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Force the mic up to max volume. Takes a few steps due to the residual | |
| // gain limitation. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillRepeatedly(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(183, helper.manager.recommended_analog_level()); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(243, helper.manager.recommended_analog_level()); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| // Manual change does not result in SetMicVolume call. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.manager.set_stream_analog_level(50); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(50, helper.manager.recommended_analog_level()); | |
| // Continues working as usual afterwards. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(20), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-38.0f)); | |
| EXPECT_EQ(69, helper.manager.recommended_analog_level()); | |
| } | |
| // Checks that, when the min mic level override is not specified, AGC ramps up | |
| // towards the minimum mic level after the mic level is manually set below the | |
| // minimum gain to enforce. | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| RecoveryAfterManualLevelChangeBelowMinWithoutMiMicLevelnOverride) { | |
| if (IsMinMicLevelOverridden()) { | |
| GTEST_SKIP() << "Skipped. Min mic level overridden."; | |
| } | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Manual change below min, but strictly positive, otherwise AGC won't take | |
| // any action. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.manager.set_stream_analog_level(1); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(1, helper.manager.recommended_analog_level()); | |
| // Continues working as usual afterwards. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-29.0f)); | |
| EXPECT_EQ(2, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(11, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(20), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-38.0f)); | |
| EXPECT_EQ(18, helper.manager.recommended_analog_level()); | |
| } | |
| // Checks that, when the min mic level override is specified, AGC immediately | |
| // applies the minimum mic level after the mic level is manually set below the | |
| // minimum gain to enforce. | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| RecoveryAfterManualLevelChangeBelowMin) { | |
| if (!IsMinMicLevelOverridden()) { | |
| GTEST_SKIP() << "Skipped. Min mic level not overridden."; | |
| } | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| // Manual change below min, but strictly positive, otherwise | |
| // AGC won't take any action. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true))); | |
| helper.manager.set_stream_analog_level(1); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-17.0f)); | |
| EXPECT_EQ(GetMinMicLevel(), helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, NoClippingHasNoImpact) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| helper.CallPreProc(/*num_calls=*/100, /*clipped_ratio=*/0); | |
| EXPECT_EQ(128, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingUnderThresholdHasNoImpact) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/0.099); | |
| EXPECT_EQ(128, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingLowersVolume) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/255, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/0.2); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, WaitingPeriodBetweenClippingChecks) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/255, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(0); | |
| helper.CallPreProc(/*num_calls=*/300, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(225, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingLoweringIsLimited) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/180, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(kClippedMin, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(0); | |
| helper.CallPreProc(/*num_calls=*/1000, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(kClippedMin, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| ClippingMaxIsRespectedWhenEqualToLevel) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/255, | |
| speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillRepeatedly(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/10, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| ClippingMaxIsRespectedWhenHigherThanLevel) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/200, | |
| speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(185, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillRepeatedly(DoAll(SetArgPointee<0>(40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-58.0f)); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| helper.CallProcess(/*num_calls=*/10, speech_probability_override, | |
| GetOverrideOrEmpty(-58.0f)); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| MaxCompressionIsIncreasedAfterClipping) { | |
| constexpr std::optional<float> kNoOverride = std::nullopt; | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/210, | |
| speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, kAboveClippedThreshold); | |
| EXPECT_EQ(195, helper.manager.recommended_analog_level()); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(11), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| helper.CallProcess(/*num_calls=*/5, speech_probability_override, | |
| GetOverrideOrEmpty(-29.0f)); | |
| // The mock `GetRmsErrorDb()` returns false; mimic this by passing | |
| // std::nullopt as an override. | |
| helper.CallProcess(/*num_calls=*/14, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(8)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(9)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(10)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(11)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(12)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(13)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| // Continue clipping until we hit the maximum surplus compression. | |
| helper.CallPreProc(/*num_calls=*/300, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(180, helper.manager.recommended_analog_level()); | |
| helper.CallPreProc(/*num_calls=*/300, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(1, kAboveClippedThreshold); | |
| EXPECT_EQ(kClippedMin, helper.manager.recommended_analog_level()); | |
| // Current level is now at the minimum, but the maximum allowed level still | |
| // has more to decrease. | |
| helper.CallPreProc(/*num_calls=*/300, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| helper.CallPreProc(/*num_calls=*/300, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| helper.CallPreProc(/*num_calls=*/300, | |
| /*clipped_ratio=*/kAboveClippedThreshold); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(16), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(16), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(16), Return(true))) | |
| .WillOnce(DoAll(SetArgPointee<0>(16), Return(true))) | |
| .WillRepeatedly(Return(false)); | |
| helper.CallProcess(/*num_calls=*/4, speech_probability_override, | |
| GetOverrideOrEmpty(-34.0f)); | |
| helper.CallProcess(/*num_calls=*/15, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(14)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(15)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(16)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(17)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/20, kNoOverride, kNoOverride); | |
| EXPECT_CALL(helper.mock_gain_control, set_compression_gain_db(18)) | |
| .WillOnce(Return(0)); | |
| helper.CallProcess(/*num_calls=*/1, kNoOverride, kNoOverride); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, UserCanRaiseVolumeAfterClipping) { | |
| const auto speech_probability_override = | |
| GetOverrideOrEmpty(kHighSpeechProbability); | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/225, | |
| speech_probability_override, | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(210, helper.manager.recommended_analog_level()); | |
| // High enough error to trigger a volume check. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(14), Return(true))); | |
| // User changed the volume. | |
| helper.manager.set_stream_analog_level(250); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(AtLeast(1)); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-32.0f)); | |
| EXPECT_EQ(250, helper.manager.recommended_analog_level()); | |
| // Move down... | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(-10), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-8.0f)); | |
| EXPECT_EQ(210, helper.manager.recommended_analog_level()); | |
| // And back up to the new max established by the user. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(40), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-58.0f)); | |
| EXPECT_EQ(250, helper.manager.recommended_analog_level()); | |
| // Will not move above new maximum. | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillOnce(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.CallProcess(/*num_calls=*/1, speech_probability_override, | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(250, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingDoesNotPullLowVolumeBackUp) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/80, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, Reset()).Times(0); | |
| int initial_volume = helper.manager.recommended_analog_level(); | |
| helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold); | |
| EXPECT_EQ(initial_volume, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, TakesNoActionOnZeroMicVolume) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(kInitialInputVolume, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_CALL(*helper.mock_agc, GetRmsErrorDb(_)) | |
| .WillRepeatedly(DoAll(SetArgPointee<0>(30), Return(true))); | |
| helper.manager.set_stream_analog_level(0); | |
| helper.CallProcess(/*num_calls=*/10, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(-48.0f)); | |
| EXPECT_EQ(0, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingDetectionLowersVolume) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/255, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| helper.CallPreProcForChangingAudio(/*num_calls=*/100, /*peak_ratio=*/0.99f); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| helper.CallPreProcForChangingAudio(/*num_calls=*/100, /*peak_ratio=*/1.0f); | |
| EXPECT_EQ(240, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| DisabledClippingPredictorDoesNotLowerVolume) { | |
| AgcManagerDirectTestHelper helper(env_); | |
| helper.CallAgcSequence(/*applied_input_volume=*/255, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_FALSE(helper.manager.clipping_predictor_enabled()); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| helper.CallPreProcForChangingAudio(/*num_calls=*/100, /*peak_ratio=*/0.99f); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| helper.CallPreProcForChangingAudio(/*num_calls=*/100, /*peak_ratio=*/0.99f); | |
| EXPECT_EQ(255, helper.manager.recommended_analog_level()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, DisableDigitalDisablesDigital) { | |
| if (IsRmsErrorOverridden()) { | |
| GTEST_SKIP() << "Skipped. RMS error override does not affect the test."; | |
| } | |
| auto agc = std::unique_ptr<Agc>(new ::testing::NiceMock<MockAgc>()); | |
| MockGainControl mock_gain_control; | |
| EXPECT_CALL(mock_gain_control, set_mode(GainControl::kFixedDigital)); | |
| EXPECT_CALL(mock_gain_control, set_target_level_dbfs(0)); | |
| EXPECT_CALL(mock_gain_control, set_compression_gain_db(0)); | |
| EXPECT_CALL(mock_gain_control, enable_limiter(false)); | |
| AnalogAgcConfig config; | |
| config.enable_digital_adaptive = false; | |
| auto manager = std::make_unique<AgcManagerDirect>(env_, kNumChannels, config); | |
| manager->Initialize(); | |
| manager->SetupDigitalGainControl(mock_gain_control); | |
| } | |
| TEST(AgcManagerDirectTest, AgcMinMicLevelExperimentDefault) { | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect(); | |
| EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel); | |
| } | |
| TEST(AgcManagerDirectTest, AgcMinMicLevelExperimentDisabled) { | |
| for (const std::string& field_trial_suffix : {"", "_20220210"}) { | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect( | |
| {.field_trials = GetAgcMinMicLevelExperimentFieldTrial( | |
| "Disabled" + field_trial_suffix)}); | |
| EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel); | |
| } | |
| } | |
| // Checks that a field-trial parameter outside of the valid range [0,255] is | |
| // ignored. | |
| TEST(AgcManagerDirectTest, AgcMinMicLevelExperimentOutOfRangeAbove) { | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect( | |
| {.field_trials = GetAgcMinMicLevelExperimentFieldTrial("Enabled-256")}); | |
| EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel); | |
| } | |
| // Checks that a field-trial parameter outside of the valid range [0,255] is | |
| // ignored. | |
| TEST(AgcManagerDirectTest, AgcMinMicLevelExperimentOutOfRangeBelow) { | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect( | |
| {.field_trials = GetAgcMinMicLevelExperimentFieldTrial("Enabled--1")}); | |
| EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevel); | |
| } | |
| // Verifies that a valid experiment changes the minimum microphone level. The | |
| // start volume is larger than the min level and should therefore not be | |
| // changed. | |
| TEST(AgcManagerDirectTest, AgcMinMicLevelExperimentEnabled50) { | |
| constexpr int kMinMicLevelOverride = 50; | |
| for (const std::string& field_trial_suffix : {"", "_20220210"}) { | |
| SCOPED_TRACE(field_trial_suffix); | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect( | |
| {.field_trials = GetAgcMinMicLevelExperimentFieldTrialEnabled( | |
| kMinMicLevelOverride, field_trial_suffix)}); | |
| EXPECT_EQ(manager->channel_agcs_[0]->min_mic_level(), kMinMicLevelOverride); | |
| } | |
| } | |
| // Checks that, when the "WebRTC-Audio-AgcMinMicLevelExperiment" field trial is | |
| // specified with a valid value, the mic level never gets lowered beyond the | |
| // override value in the presence of clipping. | |
| TEST(AgcManagerDirectTest, AgcMinMicLevelExperimentCheckMinLevelWithClipping) { | |
| constexpr int kMinMicLevelOverride = 250; | |
| // Create and initialize two AGCs by specifying and leaving unspecified the | |
| // relevant field trial. | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect(); | |
| std::unique_ptr<AgcManagerDirect> manager_with_override = | |
| CreateAgcManagerDirect( | |
| {.field_trials = GetAgcMinMicLevelExperimentFieldTrialEnabled( | |
| kMinMicLevelOverride)}); | |
| // Create a test input signal which containts 80% of clipped samples. | |
| AudioBuffer audio_buffer(kSampleRateHz, 1, kSampleRateHz, 1, kSampleRateHz, | |
| 1); | |
| WriteAudioBufferSamples(/*samples_value=*/4000.0f, /*clipped_ratio=*/0.8f, | |
| audio_buffer); | |
| // Simulate 4 seconds of clipping; it is expected to trigger a downward | |
| // adjustment of the analog gain. | |
| CallPreProcessAndProcess(/*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::nullopt, | |
| /*speech_level_override=*/std::nullopt, *manager); | |
| CallPreProcessAndProcess(/*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::nullopt, | |
| /*speech_level_override=*/std::nullopt, | |
| *manager_with_override); | |
| // Make sure that an adaptation occurred. | |
| ASSERT_GT(manager->recommended_analog_level(), 0); | |
| // Check that the test signal triggers a larger downward adaptation for | |
| // `manager`, which is allowed to reach a lower gain. | |
| EXPECT_GT(manager_with_override->recommended_analog_level(), | |
| manager->recommended_analog_level()); | |
| // Check that the gain selected by `manager_with_override` equals the minimum | |
| // value overridden via field trial. | |
| EXPECT_EQ(manager_with_override->recommended_analog_level(), | |
| kMinMicLevelOverride); | |
| } | |
| // Checks that, when the "WebRTC-Audio-AgcMinMicLevelExperiment" field trial is | |
| // specified with a valid value, the mic level never gets lowered beyond the | |
| // override value in the presence of clipping when RMS error override is used. | |
| // TODO(webrtc:7494): Revisit the test after moving the number of override wait | |
| // frames to APM config. The test passes but internally the gain update timing | |
| // differs. | |
| TEST(AgcManagerDirectTest, | |
| AgcMinMicLevelExperimentCheckMinLevelWithClippingWithRmsErrorOverride) { | |
| constexpr int kMinMicLevelOverride = 250; | |
| // Create and initialize two AGCs by specifying and leaving unspecified the | |
| // relevant field trial. | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect(); | |
| std::unique_ptr<AgcManagerDirect> manager_with_override = | |
| CreateAgcManagerDirect( | |
| {.field_trials = GetAgcMinMicLevelExperimentFieldTrialEnabled( | |
| kMinMicLevelOverride)}); | |
| // Create a test input signal which containts 80% of clipped samples. | |
| AudioBuffer audio_buffer(kSampleRateHz, 1, kSampleRateHz, 1, kSampleRateHz, | |
| 1); | |
| WriteAudioBufferSamples(/*samples_value=*/4000.0f, /*clipped_ratio=*/0.8f, | |
| audio_buffer); | |
| // Simulate 4 seconds of clipping; it is expected to trigger a downward | |
| // adjustment of the analog gain. | |
| CallPreProcessAndProcess( | |
| /*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/0.7f, | |
| /*speech_probability_level=*/-18.0f, *manager); | |
| CallPreProcessAndProcess( | |
| /*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::optional<float>(0.7f), | |
| /*speech_probability_level=*/std::optional<float>(-18.0f), | |
| *manager_with_override); | |
| // Make sure that an adaptation occurred. | |
| ASSERT_GT(manager->recommended_analog_level(), 0); | |
| // Check that the test signal triggers a larger downward adaptation for | |
| // `manager`, which is allowed to reach a lower gain. | |
| EXPECT_GT(manager_with_override->recommended_analog_level(), | |
| manager->recommended_analog_level()); | |
| // Check that the gain selected by `manager_with_override` equals the minimum | |
| // value overridden via field trial. | |
| EXPECT_EQ(manager_with_override->recommended_analog_level(), | |
| kMinMicLevelOverride); | |
| } | |
| // Checks that, when the "WebRTC-Audio-AgcMinMicLevelExperiment" field trial is | |
| // specified with a value lower than the `clipped_level_min`, the behavior of | |
| // the analog gain controller is the same as that obtained when the field trial | |
| // is not specified. | |
| TEST(AgcManagerDirectTest, | |
| AgcMinMicLevelExperimentCompareMicLevelWithClipping) { | |
| // Create and initialize two AGCs by specifying and leaving unspecified the | |
| // relevant field trial. | |
| // Use a large clipped level step to more quickly decrease the analog gain | |
| // with clipping. | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect({ | |
| .clipped_level_min = kDefaultAnalogConfig.clipped_level_min, | |
| .enable_digital_adaptive = false, | |
| .clipped_level_step = 64, | |
| }); | |
| constexpr int kMinMicLevelOverride = 20; | |
| static_assert(kDefaultAnalogConfig.clipped_level_min >= kMinMicLevelOverride, | |
| "Use a lower override value."); | |
| std::unique_ptr<AgcManagerDirect> manager_with_override = | |
| CreateAgcManagerDirect({ | |
| .field_trials = GetAgcMinMicLevelExperimentFieldTrialEnabled( | |
| kMinMicLevelOverride), | |
| .clipped_level_min = kDefaultAnalogConfig.clipped_level_min, | |
| .enable_digital_adaptive = false, | |
| .clipped_level_step = 64, | |
| }); | |
| // Create a test input signal which containts 80% of clipped samples. | |
| AudioBuffer audio_buffer(kSampleRateHz, 1, kSampleRateHz, 1, kSampleRateHz, | |
| 1); | |
| WriteAudioBufferSamples(/*samples_value=*/4000.0f, /*clipped_ratio=*/0.8f, | |
| audio_buffer); | |
| // Simulate 4 seconds of clipping; it is expected to trigger a downward | |
| // adjustment of the analog gain. | |
| CallPreProcessAndProcess(/*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::nullopt, | |
| /*speech_level_override=*/std::nullopt, *manager); | |
| CallPreProcessAndProcess(/*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::nullopt, | |
| /*speech_level_override=*/std::nullopt, | |
| *manager_with_override); | |
| // Make sure that an adaptation occurred. | |
| ASSERT_GT(manager->recommended_analog_level(), 0); | |
| // Check that the selected analog gain is the same for both controllers and | |
| // that it equals the minimum level reached when clipping is handled. That is | |
| // expected because the minimum microphone level override is less than the | |
| // minimum level used when clipping is detected. | |
| EXPECT_EQ(manager->recommended_analog_level(), | |
| manager_with_override->recommended_analog_level()); | |
| EXPECT_EQ(manager_with_override->recommended_analog_level(), | |
| kDefaultAnalogConfig.clipped_level_min); | |
| } | |
| // Checks that, when the "WebRTC-Audio-AgcMinMicLevelExperiment" field trial is | |
| // specified with a value lower than the `clipped_level_min`, the behavior of | |
| // the analog gain controller is the same as that obtained when the field trial | |
| // is not specified. | |
| // TODO(webrtc:7494): Revisit the test after moving the number of override wait | |
| // frames to APM config. The test passes but internally the gain update timing | |
| // differs. | |
| TEST(AgcManagerDirectTest, | |
| AgcMinMicLevelExperimentCompareMicLevelWithClippingWithRmsErrorOverride) { | |
| // Create and initialize two AGCs by specifying and leaving unspecified the | |
| // relevant field trial. | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect({ | |
| .clipped_level_min = kDefaultAnalogConfig.clipped_level_min, | |
| .enable_digital_adaptive = false, | |
| .clipped_level_step = 64, | |
| }); | |
| constexpr int kMinMicLevelOverride = 20; | |
| static_assert(kDefaultAnalogConfig.clipped_level_min >= kMinMicLevelOverride, | |
| "Use a lower override value."); | |
| std::unique_ptr<AgcManagerDirect> manager_with_override = | |
| CreateAgcManagerDirect({ | |
| .field_trials = GetAgcMinMicLevelExperimentFieldTrialEnabled( | |
| kMinMicLevelOverride), | |
| .clipped_level_min = kDefaultAnalogConfig.clipped_level_min, | |
| .enable_digital_adaptive = false, | |
| .clipped_level_step = 64, | |
| }); | |
| // Create a test input signal which containts 80% of clipped samples. | |
| AudioBuffer audio_buffer(kSampleRateHz, 1, kSampleRateHz, 1, kSampleRateHz, | |
| 1); | |
| WriteAudioBufferSamples(/*samples_value=*/4000.0f, /*clipped_ratio=*/0.8f, | |
| audio_buffer); | |
| CallPreProcessAndProcess( | |
| /*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::optional<float>(0.7f), | |
| /*speech_level_override=*/std::optional<float>(-18.0f), *manager); | |
| CallPreProcessAndProcess( | |
| /*num_calls=*/400, audio_buffer, | |
| /*speech_probability_override=*/std::optional<float>(0.7f), | |
| /*speech_level_override=*/std::optional<float>(-18.0f), | |
| *manager_with_override); | |
| // Make sure that an adaptation occurred. | |
| ASSERT_GT(manager->recommended_analog_level(), 0); | |
| // Check that the selected analog gain is the same for both controllers and | |
| // that it equals the minimum level reached when clipping is handled. That is | |
| // expected because the minimum microphone level override is less than the | |
| // minimum level used when clipping is detected. | |
| EXPECT_EQ(manager->recommended_analog_level(), | |
| manager_with_override->recommended_analog_level()); | |
| EXPECT_EQ(manager_with_override->recommended_analog_level(), | |
| kDefaultAnalogConfig.clipped_level_min); | |
| } | |
| // TODO(bugs.webrtc.org/12774): Test the bahavior of `clipped_level_step`. | |
| // TODO(bugs.webrtc.org/12774): Test the bahavior of `clipped_ratio_threshold`. | |
| // TODO(bugs.webrtc.org/12774): Test the bahavior of `clipped_wait_frames`. | |
| // Verifies that configurable clipping parameters are initialized as intended. | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingParametersVerified) { | |
| if (IsRmsErrorOverridden()) { | |
| GTEST_SKIP() << "Skipped. RMS error override does not affect the test."; | |
| } | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect(); | |
| EXPECT_EQ(manager->clipped_level_step_, kClippedLevelStep); | |
| EXPECT_EQ(manager->clipped_ratio_threshold_, kClippedRatioThreshold); | |
| EXPECT_EQ(manager->clipped_wait_frames_, kClippedWaitFrames); | |
| std::unique_ptr<AgcManagerDirect> manager_custom = | |
| CreateAgcManagerDirect({.clipped_level_step = 10, | |
| .clipped_ratio_threshold = 0.2f, | |
| .clipped_wait_frames = 50}); | |
| EXPECT_EQ(manager_custom->clipped_level_step_, 10); | |
| EXPECT_EQ(manager_custom->clipped_ratio_threshold_, 0.2f); | |
| EXPECT_EQ(manager_custom->clipped_wait_frames_, 50); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| DisableClippingPredictorDisablesClippingPredictor) { | |
| if (IsRmsErrorOverridden()) { | |
| GTEST_SKIP() << "Skipped. RMS error override does not affect the test."; | |
| } | |
| std::unique_ptr<AgcManagerDirect> manager = | |
| CreateAgcManagerDirect({.clipping_predictor = {.enabled = false}}); | |
| EXPECT_FALSE(manager->clipping_predictor_enabled()); | |
| EXPECT_FALSE(manager->use_clipping_predictor_step()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, ClippingPredictorDisabledByDefault) { | |
| if (IsRmsErrorOverridden()) { | |
| GTEST_SKIP() << "Skipped. RMS error override does not affect the test."; | |
| } | |
| constexpr ClippingPredictorConfig kDefaultConfig; | |
| EXPECT_FALSE(kDefaultConfig.enabled); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| EnableClippingPredictorEnablesClippingPredictor) { | |
| if (IsRmsErrorOverridden()) { | |
| GTEST_SKIP() << "Skipped. RMS error override does not affect the test."; | |
| } | |
| std::unique_ptr<AgcManagerDirect> manager = CreateAgcManagerDirect( | |
| {.clipping_predictor = {.enabled = true, .use_predicted_step = true}}); | |
| EXPECT_TRUE(manager->clipping_predictor_enabled()); | |
| EXPECT_TRUE(manager->use_clipping_predictor_step()); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| DisableClippingPredictorDoesNotLowerVolume) { | |
| AudioBuffer audio_buffer(kSampleRateHz, kNumChannels, kSampleRateHz, | |
| kNumChannels, kSampleRateHz, kNumChannels); | |
| AnalogAgcConfig config = GetAnalogAgcTestConfig(); | |
| config.clipping_predictor.enabled = false; | |
| AgcManagerDirect manager(env_, config, new ::testing::NiceMock<MockAgc>()); | |
| manager.Initialize(); | |
| manager.set_stream_analog_level(/*level=*/255); | |
| EXPECT_FALSE(manager.clipping_predictor_enabled()); | |
| EXPECT_FALSE(manager.use_clipping_predictor_step()); | |
| EXPECT_EQ(manager.recommended_analog_level(), 255); | |
| manager.Process(audio_buffer, GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, /*peak_ratio=*/0.99f, manager); | |
| EXPECT_EQ(manager.recommended_analog_level(), 255); | |
| CallPreProcessAudioBuffer(/*num_calls=*/300, /*peak_ratio=*/0.99f, manager); | |
| EXPECT_EQ(manager.recommended_analog_level(), 255); | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, /*peak_ratio=*/0.99f, manager); | |
| EXPECT_EQ(manager.recommended_analog_level(), 255); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| UsedClippingPredictionsProduceLowerAnalogLevels) { | |
| AudioBuffer audio_buffer(kSampleRateHz, kNumChannels, kSampleRateHz, | |
| kNumChannels, kSampleRateHz, kNumChannels); | |
| AnalogAgcConfig config_with_prediction = GetAnalogAgcTestConfig(); | |
| config_with_prediction.clipping_predictor.enabled = true; | |
| config_with_prediction.clipping_predictor.use_predicted_step = true; | |
| AnalogAgcConfig config_without_prediction = GetAnalogAgcTestConfig(); | |
| config_without_prediction.clipping_predictor.enabled = false; | |
| AgcManagerDirect manager_with_prediction(env_, config_with_prediction, | |
| new ::testing::NiceMock<MockAgc>()); | |
| AgcManagerDirect manager_without_prediction( | |
| env_, config_without_prediction, new ::testing::NiceMock<MockAgc>()); | |
| manager_with_prediction.Initialize(); | |
| manager_without_prediction.Initialize(); | |
| constexpr int kInitialLevel = 255; | |
| constexpr float kClippingPeakRatio = 1.0f; | |
| constexpr float kCloseToClippingPeakRatio = 0.99f; | |
| constexpr float kZeroPeakRatio = 0.0f; | |
| manager_with_prediction.set_stream_analog_level(kInitialLevel); | |
| manager_without_prediction.set_stream_analog_level(kInitialLevel); | |
| manager_with_prediction.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| manager_without_prediction.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_TRUE(manager_with_prediction.clipping_predictor_enabled()); | |
| EXPECT_FALSE(manager_without_prediction.clipping_predictor_enabled()); | |
| EXPECT_TRUE(manager_with_prediction.use_clipping_predictor_step()); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), kInitialLevel); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel); | |
| // Expect a change in the analog level when the prediction step is used. | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel); | |
| // Expect no change during waiting. | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kCloseToClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kCloseToClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel); | |
| // Expect a change when the prediction step is used. | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - 2 * kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel); | |
| // Expect no change when clipping is not detected or predicted. | |
| CallPreProcessAudioBuffer(2 * kClippedWaitFrames, kZeroPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(2 * kClippedWaitFrames, kZeroPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - 2 * kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel); | |
| // Expect a change for clipping frames. | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - 3 * kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel - kClippedLevelStep); | |
| // Expect no change during waiting. | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - 3 * kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel - kClippedLevelStep); | |
| // Expect a change for clipping frames. | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| kInitialLevel - 4 * kClippedLevelStep); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel - 2 * kClippedLevelStep); | |
| } | |
| TEST_P(AgcManagerDirectParametrizedTest, | |
| UnusedClippingPredictionsProduceEqualAnalogLevels) { | |
| AudioBuffer audio_buffer(kSampleRateHz, kNumChannels, kSampleRateHz, | |
| kNumChannels, kSampleRateHz, kNumChannels); | |
| AnalogAgcConfig config_with_prediction = GetAnalogAgcTestConfig(); | |
| config_with_prediction.clipping_predictor.enabled = true; | |
| config_with_prediction.clipping_predictor.use_predicted_step = false; | |
| AnalogAgcConfig config_without_prediction = GetAnalogAgcTestConfig(); | |
| config_without_prediction.clipping_predictor.enabled = false; | |
| AgcManagerDirect manager_with_prediction(env_, config_with_prediction, | |
| new ::testing::NiceMock<MockAgc>()); | |
| AgcManagerDirect manager_without_prediction( | |
| env_, config_without_prediction, new ::testing::NiceMock<MockAgc>()); | |
| constexpr int kInitialLevel = 255; | |
| constexpr float kClippingPeakRatio = 1.0f; | |
| constexpr float kCloseToClippingPeakRatio = 0.99f; | |
| constexpr float kZeroPeakRatio = 0.0f; | |
| manager_with_prediction.Initialize(); | |
| manager_without_prediction.Initialize(); | |
| manager_with_prediction.set_stream_analog_level(kInitialLevel); | |
| manager_without_prediction.set_stream_analog_level(kInitialLevel); | |
| manager_with_prediction.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| manager_without_prediction.Process(audio_buffer, | |
| GetOverrideOrEmpty(kHighSpeechProbability), | |
| GetOverrideOrEmpty(kSpeechLevelDbfs)); | |
| EXPECT_TRUE(manager_with_prediction.clipping_predictor_enabled()); | |
| EXPECT_FALSE(manager_without_prediction.clipping_predictor_enabled()); | |
| EXPECT_FALSE(manager_with_prediction.use_clipping_predictor_step()); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), kInitialLevel); | |
| EXPECT_EQ(manager_without_prediction.recommended_analog_level(), | |
| kInitialLevel); | |
| // Expect no change in the analog level for non-clipping frames. | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| // Expect no change for non-clipping frames. | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kCloseToClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kCloseToClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| // Expect no change for non-clipping frames. | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/10, kCloseToClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| // Expect no change when clipping is not detected or predicted. | |
| CallPreProcessAudioBuffer(2 * kClippedWaitFrames, kZeroPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(2 * kClippedWaitFrames, kZeroPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| // Expect a change for clipping frames. | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| // Expect no change during waiting. | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(kClippedWaitFrames, kClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| // Expect a change for clipping frames. | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_with_prediction); | |
| CallPreProcessAudioBuffer(/*num_calls=*/1, kClippingPeakRatio, | |
| manager_without_prediction); | |
| EXPECT_EQ(manager_with_prediction.recommended_analog_level(), | |
| manager_without_prediction.recommended_analog_level()); | |
| } | |
| // Checks that passing an empty speech level and probability overrides to | |
| // `Process()` has the same effect as passing no overrides. | |
| TEST_P(AgcManagerDirectParametrizedTest, EmptyRmsErrorOverrideHasNoEffect) { | |
| AgcManagerDirect manager_1(env_, kNumChannels, GetAnalogAgcTestConfig()); | |
| AgcManagerDirect manager_2(env_, kNumChannels, GetAnalogAgcTestConfig()); | |
| manager_1.Initialize(); | |
| manager_2.Initialize(); | |
| constexpr int kAnalogLevel = 50; | |
| manager_1.set_stream_analog_level(kAnalogLevel); | |
| manager_2.set_stream_analog_level(kAnalogLevel); | |
| // Feed speech with low energy to trigger an upward adapation of the analog | |
| // level. | |
| constexpr int kNumFrames = 125; | |
| constexpr int kGainDb = -20; | |
| SpeechSamplesReader reader; | |
| // Check the initial input volume. | |
| ASSERT_EQ(manager_1.recommended_analog_level(), kAnalogLevel); | |
| ASSERT_EQ(manager_2.recommended_analog_level(), kAnalogLevel); | |
| reader.Feed(kNumFrames, kGainDb, std::nullopt, std::nullopt, manager_1); | |
| reader.Feed(kNumFrames, kGainDb, manager_2); | |
| // Check that the states are the same and adaptation occurs. | |
| EXPECT_EQ(manager_1.recommended_analog_level(), | |
| manager_2.recommended_analog_level()); | |
| ASSERT_GT(manager_1.recommended_analog_level(), kAnalogLevel); | |
| EXPECT_EQ(manager_1.voice_probability(), manager_2.voice_probability()); | |
| EXPECT_EQ(manager_1.frames_since_clipped_, manager_2.frames_since_clipped_); | |
| // Check that the states of the channel AGCs are the same. | |
| EXPECT_EQ(manager_1.num_channels(), manager_2.num_channels()); | |
| for (int i = 0; i < manager_1.num_channels(); ++i) { | |
| EXPECT_EQ(manager_1.channel_agcs_[i]->recommended_analog_level(), | |
| manager_2.channel_agcs_[i]->recommended_analog_level()); | |
| EXPECT_EQ(manager_1.channel_agcs_[i]->voice_probability(), | |
| manager_2.channel_agcs_[i]->voice_probability()); | |
| } | |
| } | |
| // Checks that passing a non-empty speech level and probability overrides to | |
| // `Process()` has an effect. | |
| TEST_P(AgcManagerDirectParametrizedTest, NonEmptyRmsErrorOverrideHasEffect) { | |
| AgcManagerDirect manager_1(env_, kNumChannels, GetAnalogAgcTestConfig()); | |
| AgcManagerDirect manager_2(env_, kNumChannels, GetAnalogAgcTestConfig()); | |
| manager_1.Initialize(); | |
| manager_2.Initialize(); | |
| constexpr int kInputVolume = 128; | |
| manager_1.set_stream_analog_level(kInputVolume); | |
| manager_2.set_stream_analog_level(kInputVolume); | |
| // Feed speech with low energy to trigger an upward adapation of the input | |
| // volume. | |
| constexpr int kNumFrames = 125; | |
| constexpr int kGainDb = -20; | |
| SpeechSamplesReader reader; | |
| // Make sure that the feeding samples triggers an adaptation when no override | |
| // is specified. | |
| reader.Feed(kNumFrames, kGainDb, manager_1); | |
| ASSERT_GT(manager_1.recommended_analog_level(), kInputVolume); | |
| // Expect that feeding samples triggers an adaptation when the speech | |
| // probability and speech level overrides are specified. | |
| reader.Feed(kNumFrames, kGainDb, | |
| /*speech_probability_override=*/kHighSpeechProbability, | |
| /*speech_level_override=*/-45.0f, manager_2); | |
| EXPECT_GT(manager_2.recommended_analog_level(), kInputVolume); | |
| // The voice probability override does not affect the `voice_probability()` | |
| // getter. | |
| EXPECT_EQ(manager_1.voice_probability(), manager_2.voice_probability()); | |
| } | |
| class AgcManagerDirectChannelSampleRateTest | |
| : public ::testing::TestWithParam<std::tuple<int, int>> { | |
| protected: | |
| int GetNumChannels() const { return std::get<0>(GetParam()); } | |
| int GetSampleRateHz() const { return std::get<1>(GetParam()); } | |
| }; | |
| TEST_P(AgcManagerDirectChannelSampleRateTest, CheckIsAlive) { | |
| const int num_channels = GetNumChannels(); | |
| const int sample_rate_hz = GetSampleRateHz(); | |
| constexpr AnalogAgcConfig kConfig{.enabled = true, | |
| .clipping_predictor{.enabled = true}}; | |
| AgcManagerDirect manager(CreateEnvironment(), num_channels, kConfig); | |
| manager.Initialize(); | |
| AudioBuffer buffer(sample_rate_hz, num_channels, sample_rate_hz, num_channels, | |
| sample_rate_hz, num_channels); | |
| constexpr int kStartupVolume = 100; | |
| int applied_initial_volume = kStartupVolume; | |
| // Trigger a downward adaptation with clipping. | |
| WriteAudioBufferSamples(/*samples_value=*/0.0f, /*clipped_ratio=*/0.5f, | |
| buffer); | |
| const int initial_volume1 = applied_initial_volume; | |
| for (int i = 0; i < 400; ++i) { | |
| manager.set_stream_analog_level(applied_initial_volume); | |
| manager.AnalyzePreProcess(buffer); | |
| manager.Process(buffer, kLowSpeechProbability, | |
| /*speech_level_dbfs=*/-20.0f); | |
| applied_initial_volume = manager.recommended_analog_level(); | |
| } | |
| ASSERT_LT(manager.recommended_analog_level(), initial_volume1); | |
| // Fill in audio that does not clip. | |
| WriteAudioBufferSamples(/*samples_value=*/1234.5f, /*clipped_ratio=*/0.0f, | |
| buffer); | |
| // Trigger an upward adaptation. | |
| const int initial_volume2 = manager.recommended_analog_level(); | |
| for (int i = 0; i < kConfig.clipped_wait_frames; ++i) { | |
| manager.set_stream_analog_level(applied_initial_volume); | |
| manager.AnalyzePreProcess(buffer); | |
| manager.Process(buffer, kHighSpeechProbability, | |
| /*speech_level_dbfs=*/-65.0f); | |
| applied_initial_volume = manager.recommended_analog_level(); | |
| } | |
| EXPECT_GT(manager.recommended_analog_level(), initial_volume2); | |
| // Trigger a downward adaptation. | |
| const int initial_volume = manager.recommended_analog_level(); | |
| for (int i = 0; i < 100; ++i) { | |
| manager.set_stream_analog_level(applied_initial_volume); | |
| manager.AnalyzePreProcess(buffer); | |
| manager.Process(buffer, kHighSpeechProbability, | |
| /*speech_level_dbfs=*/-5.0f); | |
| applied_initial_volume = manager.recommended_analog_level(); | |
| } | |
| EXPECT_LT(manager.recommended_analog_level(), initial_volume); | |
| } | |
| INSTANTIATE_TEST_SUITE_P( | |
| , | |
| AgcManagerDirectChannelSampleRateTest, | |
| ::testing::Combine(::testing::Values(1, 2, 3, 6), | |
| ::testing::Values(8000, 16000, 32000, 48000))); | |
| } // namespace webrtc |