admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

InputVolumeController: Restrict the application of min input volume

Browse Source 
Only allow the application of min input volume if the applied input
volume is above zero. To implement this, add a member variable to
store the applied input volume. Rename the related setter to reflect
its new functionality.

Bug: webrtc:7494
Change-Id: Ia70d5cb4dfd972aad9ef2663a81884f3e5cb0758
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/287680
Reviewed-by: Alessio Bazzica <alessiob@webrtc.org>
Commit-Queue: Hanna Silen <silen@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38878}
This commit is contained in:
Hanna Silen 2022-12-12 18:23:57 +01:00 committed by WebRTC LUCI CQ
parent 8d74b28518
commit cdee165646
4 changed files with 140 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
modules/audio_processing/agc2/input_volume_controller.cc
View File

@ -551,7 +551,9 @@ void InputVolumeController::HandleCaptureOutputUsedChange(
capture_output_used_ = capture_output_used;
}
void InputVolumeController::set_stream_analog_level(int input_volume) {
void InputVolumeController::SetAppliedInputVolume(int input_volume) {
applied_input_volume_ = input_volume;
for (auto& controller : channel_controllers_) {
controller->set_stream_analog_level(input_volume);
}
@ -572,7 +574,7 @@ void InputVolumeController::AggregateChannelLevels() {
}
// Enforce the minimum input volume when a recommendation is made.
if (new_recommended_input_volume > 0) {
if (applied_input_volume_ > 0) {
new_recommended_input_volume =
std::max(new_recommended_input_volume, min_input_volume_);
}

22
modules/audio_processing/agc2/input_volume_controller.h
View File

@ -82,7 +82,7 @@ class InputVolumeController final {
void Initialize();
// Sets the applied input volume.
void set_stream_analog_level(int level);
void SetAppliedInputVolume(int level);
// TODO(bugs.webrtc.org/7494): Add argument for the applied input volume and
// remove `set_stream_analog_level()`.
@ -101,13 +101,11 @@ class InputVolumeController final {
void Process(float speech_probability,
absl::optional<float> speech_level_dbfs);
// TODO(bugs.webrtc.org/7494): Return recommended input volume and remove
// `recommended_analog_level()`.
// Returns the recommended input volume. If the input volume contoller is
// disabled, returns the input volume set via the latest
// `set_stream_analog_level()` call. Must be called after
// `AnalyzePreProcess()` and `Process()`.
int recommended_analog_level() const { return recommended_input_volume_; }
// `SetAppliedInputVolume()` call. Must be called after `AnalyzePreProcess()`
// and `Process()`.
int recommended_input_volume() const { return recommended_input_volume_; }
// Stores whether the capture output will be used or not. Call when the
// capture stream output has been flagged to be used/not-used. If unused, the
@ -144,15 +142,17 @@ class InputVolumeController final {
// Minimum input volume that can be recommended.
const int min_input_volume_;
// TODO(bugs.webrtc.org/7494): Create a separate member for the applied input
// volume.
// TODO(bugs.webrtc.org/7494): Once
// `AudioProcessingImpl::recommended_stream_analog_level()` becomes a trivial
// getter, leave uninitialized.
// Recommended input volume. After `set_stream_analog_level()` is called it
// holds the observed input volume. Possibly updated by `AnalyzePreProcess()`
// and `Process()`; after these calls, holds the recommended input volume.
// Recommended input volume. After `SetAppliedInputVolume()` is called it
// holds holds the observed input volume. Possibly updated by
// `AnalyzePreProcess()` and `Process()`; after these calls, holds the
// recommended input volume.
int recommended_input_volume_ = 0;
// Applied input volume. After `SetAppliedInputVolume()` is called it holds
// the current applied volume.
int applied_input_volume_ = 0;
bool capture_output_used_;

246
modules/audio_processing/agc2/input_volume_controller_unittest.cc
View File

@ -216,10 +216,10 @@ class SpeechSamplesReader {
return rtc::SafeClamp(static_cast<float>(v) * gain,
kMinSample, kMaxSample);
});
controller.set_stream_analog_level(applied_input_volume);
controller.SetAppliedInputVolume(applied_input_volume);
controller.AnalyzePreProcess(audio_buffer_);
controller.Process(speech_probability, speech_level_dbfs);
applied_input_volume = controller.recommended_analog_level();
applied_input_volume = controller.recommended_input_volume();
}
}
@ -232,14 +232,14 @@ class SpeechSamplesReader {
// Runs the MonoInputVolumeControl processing sequence following the API
// contract. Returns the updated recommended input volume.
float UpdateRecommendedInputVolume(MonoInputVolumeController& controller,
float UpdateRecommendedInputVolume(MonoInputVolumeController& mono_controller,
int applied_input_volume,
float speech_probability,
absl::optional<float> rms_error_dbfs) {
controller.set_stream_analog_level(applied_input_volume);
EXPECT_EQ(controller.recommended_analog_level(), applied_input_volume);
controller.Process(rms_error_dbfs, speech_probability);
return controller.recommended_analog_level();
mono_controller.set_stream_analog_level(applied_input_volume);
EXPECT_EQ(mono_controller.recommended_analog_level(), applied_input_volume);
mono_controller.Process(rms_error_dbfs, speech_probability);
return mono_controller.recommended_analog_level();
}
} // namespace
@ -297,10 +297,10 @@ class InputVolumeControllerTestHelper {
int volume = applied_input_volume;
for (int i = 0; i < num_calls; ++i) {
controller.set_stream_analog_level(volume);
controller.SetAppliedInputVolume(volume);
controller.AnalyzePreProcess(audio_buffer);
controller.Process(speech_probability, speech_level_dbfs);
volume = controller.recommended_analog_level();
volume = controller.recommended_input_volume();
}
return volume;
}
@ -356,7 +356,7 @@ TEST_P(InputVolumeControllerParametrizedTest,
helper.CallAgcSequence(kInitialInputVolume, kHighSpeechProbability,
kSpeechLevel);
EXPECT_EQ(kInitialInputVolume, helper.controller.recommended_analog_level());
EXPECT_EQ(kInitialInputVolume, helper.controller.recommended_input_volume());
}
TEST_P(InputVolumeControllerParametrizedTest, MicVolumeResponseToRmsError) {
@ -372,10 +372,10 @@ TEST_P(InputVolumeControllerParametrizedTest, MicVolumeResponseToRmsError) {
// Above the digital gain's window; volume should be increased.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -29.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 128);
EXPECT_EQ(helper.controller.recommended_input_volume(), 128);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -38.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 156);
EXPECT_EQ(helper.controller.recommended_input_volume(), 156);
// Inside the digital gain's window; no change of volume.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -23.0f);
@ -383,13 +383,13 @@ TEST_P(InputVolumeControllerParametrizedTest, MicVolumeResponseToRmsError) {
// Below the digial gain's window; volume should be decreased.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 155);
EXPECT_EQ(helper.controller.recommended_input_volume(), 155);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 151);
EXPECT_EQ(helper.controller.recommended_input_volume(), 151);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -9.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 119);
EXPECT_EQ(helper.controller.recommended_input_volume(), 119);
}
TEST_P(InputVolumeControllerParametrizedTest, MicVolumeIsLimited) {
@ -399,41 +399,41 @@ TEST_P(InputVolumeControllerParametrizedTest, MicVolumeIsLimited) {
// Maximum upwards change is limited.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 183);
EXPECT_EQ(helper.controller.recommended_input_volume(), 183);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 243);
EXPECT_EQ(helper.controller.recommended_input_volume(), 243);
// Won't go higher than the maximum.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 255);
EXPECT_EQ(helper.controller.recommended_input_volume(), 255);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 254);
EXPECT_EQ(helper.controller.recommended_input_volume(), 254);
// Maximum downwards change is limited.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 194);
EXPECT_EQ(helper.controller.recommended_input_volume(), 194);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 137);
EXPECT_EQ(helper.controller.recommended_input_volume(), 137);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 88);
EXPECT_EQ(helper.controller.recommended_input_volume(), 88);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 54);
EXPECT_EQ(helper.controller.recommended_input_volume(), 54);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 33);
EXPECT_EQ(helper.controller.recommended_input_volume(), 33);
// Won't go lower than the minimum.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(),
EXPECT_EQ(helper.controller.recommended_input_volume(),
std::max(18, GetMinInputVolume()));
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, 22.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(),
EXPECT_EQ(helper.controller.recommended_input_volume(),
std::max(12, GetMinInputVolume()));
}
@ -456,11 +456,11 @@ TEST_P(InputVolumeControllerParametrizedTest,
helper.controller.HandleCaptureOutputUsedChange(true);
constexpr int kInputVolume = 127;
helper.controller.set_stream_analog_level(kInputVolume);
helper.controller.SetAppliedInputVolume(kInputVolume);
// SetMicVolume should not be called.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, kSpeechLevel);
EXPECT_EQ(helper.controller.recommended_analog_level(), 127);
EXPECT_EQ(helper.controller.recommended_input_volume(), 127);
}
TEST_P(InputVolumeControllerParametrizedTest, UnmutingRaisesTooLowVolume) {
@ -472,10 +472,10 @@ TEST_P(InputVolumeControllerParametrizedTest, UnmutingRaisesTooLowVolume) {
helper.controller.HandleCaptureOutputUsedChange(true);
constexpr int kInputVolume = 11;
helper.controller.set_stream_analog_level(kInputVolume);
helper.controller.SetAppliedInputVolume(kInputVolume);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, kSpeechLevel);
EXPECT_EQ(helper.controller.recommended_analog_level(), GetMinInputVolume());
EXPECT_EQ(helper.controller.recommended_input_volume(), GetMinInputVolume());
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -486,19 +486,19 @@ TEST_P(InputVolumeControllerParametrizedTest,
// GetMicVolume returns a value outside of the quantization slack, indicating
// a manual volume change.
ASSERT_NE(helper.controller.recommended_analog_level(), 154);
helper.controller.set_stream_analog_level(154);
ASSERT_NE(helper.controller.recommended_input_volume(), 154);
helper.controller.SetAppliedInputVolume(154);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -29.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 154);
EXPECT_EQ(helper.controller.recommended_input_volume(), 154);
// Do the same thing, except downwards now.
helper.controller.set_stream_analog_level(100);
helper.controller.SetAppliedInputVolume(100);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 100);
EXPECT_EQ(helper.controller.recommended_input_volume(), 100);
// And finally verify the AGC continues working without a manual change.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 99);
EXPECT_EQ(helper.controller.recommended_input_volume(), 99);
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -510,21 +510,21 @@ TEST_P(InputVolumeControllerParametrizedTest,
// Force the mic up to max volume. Takes a few steps due to the residual
// gain limitation.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 183);
EXPECT_EQ(helper.controller.recommended_input_volume(), 183);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 243);
EXPECT_EQ(helper.controller.recommended_input_volume(), 243);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 255);
EXPECT_EQ(helper.controller.recommended_input_volume(), 255);
// Manual change does not result in SetMicVolume call.
helper.controller.set_stream_analog_level(50);
helper.controller.SetAppliedInputVolume(50);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 50);
EXPECT_EQ(helper.controller.recommended_input_volume(), 50);
// Continues working as usual afterwards.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -38.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 65);
EXPECT_EQ(helper.controller.recommended_input_volume(), 65);
}
// Checks that the minimum input volume is enforced during the upward adjustment
@ -537,20 +537,20 @@ TEST_P(InputVolumeControllerParametrizedTest,
// Manual change below min, but strictly positive, otherwise no action will be
// taken.
helper.controller.set_stream_analog_level(1);
helper.controller.SetAppliedInputVolume(1);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
// Trigger an upward adjustment of the input volume.
EXPECT_EQ(helper.controller.recommended_analog_level(), GetMinInputVolume());
EXPECT_EQ(helper.controller.recommended_input_volume(), GetMinInputVolume());
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -29.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), GetMinInputVolume());
EXPECT_EQ(helper.controller.recommended_input_volume(), GetMinInputVolume());
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), GetMinInputVolume());
EXPECT_EQ(helper.controller.recommended_input_volume(), GetMinInputVolume());
// After a number of consistently low speech level observations, the input
// volume is eventually raised above the minimum.
helper.CallProcess(/*num_calls=*/10, kHighSpeechProbability, -38.0f);
EXPECT_GT(helper.controller.recommended_analog_level(), GetMinInputVolume());
EXPECT_GT(helper.controller.recommended_input_volume(), GetMinInputVolume());
}
// Checks that, when the min mic level override is specified, AGC immediately
@ -564,9 +564,9 @@ TEST_P(InputVolumeControllerParametrizedTest,
// Manual change below min, but strictly positive, otherwise
// AGC won't take any action.
helper.controller.set_stream_analog_level(1);
helper.controller.SetAppliedInputVolume(1);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -17.0f);
EXPECT_EQ(GetMinInputVolume(), helper.controller.recommended_analog_level());
EXPECT_EQ(GetMinInputVolume(), helper.controller.recommended_input_volume());
}
TEST_P(InputVolumeControllerParametrizedTest, NoClippingHasNoImpact) {
@ -575,7 +575,7 @@ TEST_P(InputVolumeControllerParametrizedTest, NoClippingHasNoImpact) {
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/100, /*clipped_ratio=*/0);
EXPECT_EQ(helper.controller.recommended_analog_level(), 128);
EXPECT_EQ(helper.controller.recommended_input_volume(), 128);
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -585,7 +585,7 @@ TEST_P(InputVolumeControllerParametrizedTest,
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/0.099);
EXPECT_EQ(helper.controller.recommended_analog_level(), 128);
EXPECT_EQ(helper.controller.recommended_input_volume(), 128);
}
TEST_P(InputVolumeControllerParametrizedTest, ClippingLowersVolume) {
@ -594,7 +594,7 @@ TEST_P(InputVolumeControllerParametrizedTest, ClippingLowersVolume) {
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/0.2);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -604,14 +604,14 @@ TEST_P(InputVolumeControllerParametrizedTest,
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
helper.CallPreProc(/*num_calls=*/300,
/*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), 225);
EXPECT_EQ(helper.controller.recommended_input_volume(), 225);
}
TEST_P(InputVolumeControllerParametrizedTest, ClippingLoweringIsLimited) {
@ -620,11 +620,11 @@ TEST_P(InputVolumeControllerParametrizedTest, ClippingLoweringIsLimited) {
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), kClippedMin);
EXPECT_EQ(helper.controller.recommended_input_volume(), kClippedMin);
helper.CallPreProc(/*num_calls=*/1000,
/*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), kClippedMin);
EXPECT_EQ(helper.controller.recommended_input_volume(), kClippedMin);
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -634,10 +634,10 @@ TEST_P(InputVolumeControllerParametrizedTest,
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
helper.CallProcess(/*num_calls=*/10, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -647,12 +647,12 @@ TEST_P(InputVolumeControllerParametrizedTest,
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), 185);
EXPECT_EQ(helper.controller.recommended_input_volume(), 185);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -58.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
helper.CallProcess(/*num_calls=*/10, kHighSpeechProbability, -58.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 240);
EXPECT_EQ(helper.controller.recommended_input_volume(), 240);
}
TEST_P(InputVolumeControllerParametrizedTest, UserCanRaiseVolumeAfterClipping) {
@ -661,22 +661,22 @@ TEST_P(InputVolumeControllerParametrizedTest, UserCanRaiseVolumeAfterClipping) {
kSpeechLevel);
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(helper.controller.recommended_analog_level(), 210);
EXPECT_EQ(helper.controller.recommended_input_volume(), 210);
// User changed the volume.
helper.controller.set_stream_analog_level(250);
helper.controller.SetAppliedInputVolume(250);
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -32.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 250);
EXPECT_EQ(helper.controller.recommended_input_volume(), 250);
// Move down...
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -8.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 210);
EXPECT_EQ(helper.controller.recommended_input_volume(), 210);
// And back up to the new max established by the user.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -58.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 250);
EXPECT_EQ(helper.controller.recommended_input_volume(), 250);
// Will not move above new maximum.
helper.CallProcess(/*num_calls=*/1, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 250);
EXPECT_EQ(helper.controller.recommended_input_volume(), 250);
}
TEST_P(InputVolumeControllerParametrizedTest,
@ -685,9 +685,9 @@ TEST_P(InputVolumeControllerParametrizedTest,
helper.CallAgcSequence(/*applied_input_volume=*/80, kHighSpeechProbability,
kSpeechLevel);
int initial_volume = helper.controller.recommended_analog_level();
int initial_volume = helper.controller.recommended_input_volume();
helper.CallPreProc(/*num_calls=*/1, /*clipped_ratio=*/kAboveClippedThreshold);
EXPECT_EQ(initial_volume, helper.controller.recommended_analog_level());
EXPECT_EQ(initial_volume, helper.controller.recommended_input_volume());
}
TEST_P(InputVolumeControllerParametrizedTest, TakesNoActionOnZeroMicVolume) {
@ -695,9 +695,9 @@ TEST_P(InputVolumeControllerParametrizedTest, TakesNoActionOnZeroMicVolume) {
helper.CallAgcSequence(kInitialInputVolume, kHighSpeechProbability,
kSpeechLevel);
helper.controller.set_stream_analog_level(0);
helper.controller.SetAppliedInputVolume(0);
helper.CallProcess(/*num_calls=*/10, kHighSpeechProbability, -48.0f);
EXPECT_EQ(helper.controller.recommended_analog_level(), 0);
EXPECT_EQ(helper.controller.recommended_input_volume(), 0);
}
TEST_P(InputVolumeControllerParametrizedTest, ClippingDetectionLowersVolume) {
@ -797,7 +797,7 @@ TEST(InputVolumeControllerTest, MinInputVolumeCheckMinLevelWithClipping) {
CreateInputVolumeController(kClippedLevelStep, kClippedRatioThreshold,
kClippedWaitFrames);
controller->Initialize();
controller->set_stream_analog_level(kInitialInputVolume);
controller->SetAppliedInputVolume(kInitialInputVolume);
return controller;
};
std::unique_ptr<InputVolumeController> controller = factory();
@ -825,15 +825,15 @@ TEST(InputVolumeControllerTest, MinInputVolumeCheckMinLevelWithClipping) {
*controller_with_override);
// Make sure that an adaptation occurred.
ASSERT_GT(controller->recommended_analog_level(), 0);
ASSERT_GT(controller->recommended_input_volume(), 0);
// Check that the test signal triggers a larger downward adaptation for
// `controller`, which is allowed to reach a lower gain.
EXPECT_GT(controller_with_override->recommended_analog_level(),
controller->recommended_analog_level());
EXPECT_GT(controller_with_override->recommended_input_volume(),
controller->recommended_input_volume());
// Check that the gain selected by `controller_with_override` equals the
// minimum value overridden via field trial.
EXPECT_EQ(controller_with_override->recommended_analog_level(),
EXPECT_EQ(controller_with_override->recommended_input_volume(),
kMinInputVolume);
}
@ -854,7 +854,7 @@ TEST(InputVolumeControllerTest,
CreateInputVolumeController(kClippedLevelStep, kClippedRatioThreshold,
kClippedWaitFrames);
controller->Initialize();
controller->set_stream_analog_level(kInitialInputVolume);
controller->SetAppliedInputVolume(kInitialInputVolume);
return controller;
};
std::unique_ptr<InputVolumeController> controller = factory();
@ -881,15 +881,15 @@ TEST(InputVolumeControllerTest,
/*speech_level_dbfs=*/-18.0f, *controller_with_override);
// Make sure that an adaptation occurred.
ASSERT_GT(controller->recommended_analog_level(), 0);
ASSERT_GT(controller->recommended_input_volume(), 0);
// Check that the test signal triggers a larger downward adaptation for
// `controller`, which is allowed to reach a lower gain.
EXPECT_GT(controller_with_override->recommended_analog_level(),
controller->recommended_analog_level());
EXPECT_GT(controller_with_override->recommended_input_volume(),
controller->recommended_input_volume());
// Check that the gain selected by `controller_with_override` equals the
// minimum value overridden via field trial.
EXPECT_EQ(controller_with_override->recommended_analog_level(),
EXPECT_EQ(controller_with_override->recommended_input_volume(),
kMinInputVolume);
}
@ -910,7 +910,7 @@ TEST(InputVolumeControllerTest, MinInputVolumeCompareMicLevelWithClipping) {
auto controller = std::make_unique<InputVolumeController>(
/*num_capture_channels=*/1, config);
controller->Initialize();
controller->set_stream_analog_level(kInitialInputVolume);
controller->SetAppliedInputVolume(kInitialInputVolume);
return controller;
};
std::unique_ptr<InputVolumeController> controller = factory();
@ -942,15 +942,15 @@ TEST(InputVolumeControllerTest, MinInputVolumeCompareMicLevelWithClipping) {
*controller_with_override);
// Make sure that an adaptation occurred.
ASSERT_GT(controller->recommended_analog_level(), 0);
ASSERT_GT(controller->recommended_input_volume(), 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(controller->recommended_analog_level(),
controller_with_override->recommended_analog_level());
EXPECT_EQ(controller_with_override->recommended_analog_level(),
EXPECT_EQ(controller->recommended_input_volume(),
controller_with_override->recommended_input_volume());
EXPECT_EQ(controller_with_override->recommended_input_volume(),
kDefaultInputVolumeControllerConfig.clipped_level_min);
}
@ -975,7 +975,7 @@ TEST(InputVolumeControllerTest,
auto controller = std::make_unique<InputVolumeController>(
/*num_capture_channels=*/1, config);
controller->Initialize();
controller->set_stream_analog_level(kInitialInputVolume);
controller->SetAppliedInputVolume(kInitialInputVolume);
return controller;
};
std::unique_ptr<InputVolumeController> controller = factory();
@ -1006,15 +1006,15 @@ TEST(InputVolumeControllerTest,
/*speech_level_dbfs=*/-18.0f, *controller_with_override);
// Make sure that an adaptation occurred.
ASSERT_GT(controller->recommended_analog_level(), 0);
ASSERT_GT(controller->recommended_input_volume(), 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(controller->recommended_analog_level(),
controller_with_override->recommended_analog_level());
EXPECT_EQ(controller_with_override->recommended_analog_level(),
EXPECT_EQ(controller->recommended_input_volume(),
controller_with_override->recommended_input_volume());
EXPECT_EQ(controller_with_override->recommended_input_volume(),
kDefaultInputVolumeControllerConfig.clipped_level_min);
}
@ -1264,7 +1264,7 @@ TEST_P(InputVolumeControllerParametrizedTest, EmptyRmsErrorHasNoEffect) {
absl::nullopt, controller);
// Check that no adaptation occurs.
ASSERT_EQ(controller.recommended_analog_level(), kInitialInputVolume);
ASSERT_EQ(controller.recommended_input_volume(), kInitialInputVolume);
}
// Checks that the recommended input volume is not updated unless enough
@ -1294,20 +1294,20 @@ TEST(InputVolumeControllerTest, UpdateInputVolumeWaitFramesIsEffective) {
/*speech_level_dbfs=*/-42.0f, *controller_wait_100);
// Check that adaptation only occurs if enough frames have been processed.
ASSERT_GT(controller_wait_0->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_wait_100->recommended_analog_level(), kInputVolume);
ASSERT_GT(controller_wait_0->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_wait_100->recommended_input_volume(), kInputVolume);
reader_1.Feed(/*num_frames=*/1, controller_wait_0->recommended_analog_level(),
reader_1.Feed(/*num_frames=*/1, controller_wait_0->recommended_input_volume(),
/*gain_db=*/0, kHighSpeechProbability,
/*speech_level_dbfs=*/-42.0f, *controller_wait_0);
reader_2.Feed(/*num_frames=*/1,
controller_wait_100->recommended_analog_level(), /*gain_db=*/0,
controller_wait_100->recommended_input_volume(), /*gain_db=*/0,
kHighSpeechProbability,
/*speech_level_dbfs=*/-42.0f, *controller_wait_100);
// Check that adaptation only occurs when enough frames have been processed.
ASSERT_GT(controller_wait_0->recommended_analog_level(), kInputVolume);
ASSERT_GT(controller_wait_100->recommended_analog_level(), kInputVolume);
ASSERT_GT(controller_wait_0->recommended_input_volume(), kInputVolume);
ASSERT_GT(controller_wait_100->recommended_input_volume(), kInputVolume);
}
TEST(InputVolumeControllerTest, SpeechRatioThresholdIsEffective) {
@ -1337,28 +1337,28 @@ TEST(InputVolumeControllerTest, SpeechRatioThresholdIsEffective) {
/*speech_probability=*/0.4f, /*speech_level_dbfs=*/-42.0f,
*controller_2);
ASSERT_EQ(controller_1->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_2->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_1->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_2->recommended_input_volume(), kInputVolume);
reader_1.Feed(
/*num_frames=*/2, controller_1->recommended_analog_level(), /*gain_db=*/0,
/*num_frames=*/2, controller_1->recommended_input_volume(), /*gain_db=*/0,
/*speech_probability=*/0.4f, /*speech_level_dbfs=*/-42.0f, *controller_1);
reader_2.Feed(
/*num_frames=*/2, controller_2->recommended_analog_level(), /*gain_db=*/0,
/*num_frames=*/2, controller_2->recommended_input_volume(), /*gain_db=*/0,
/*speech_probability=*/0.4f, /*speech_level_dbfs=*/-42.0f, *controller_2);
ASSERT_EQ(controller_1->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_2->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_1->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_2->recommended_input_volume(), kInputVolume);
reader_1.Feed(
/*num_frames=*/7, controller_1->recommended_analog_level(), /*gain_db=*/0,
/*num_frames=*/7, controller_1->recommended_input_volume(), /*gain_db=*/0,
/*speech_probability=*/0.7f, /*speech_level_dbfs=*/-42.0f, *controller_1);
reader_2.Feed(
/*num_frames=*/7, controller_2->recommended_analog_level(), /*gain_db=*/0,
/*num_frames=*/7, controller_2->recommended_input_volume(), /*gain_db=*/0,
/*speech_probability=*/0.7f, /*speech_level_dbfs=*/-42.0f, *controller_2);
ASSERT_GT(controller_1->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_2->recommended_analog_level(), kInputVolume);
ASSERT_GT(controller_1->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_2->recommended_input_volume(), kInputVolume);
}
TEST(InputVolumeControllerTest, SpeechProbabilityThresholdIsEffective) {
@ -1392,30 +1392,30 @@ TEST(InputVolumeControllerTest, SpeechProbabilityThresholdIsEffective) {
/*speech_probability=*/0.49f, /*speech_level_dbfs=*/-42.0f,
*controller_2);
ASSERT_EQ(controller_1->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_2->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_1->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_2->recommended_input_volume(), kInputVolume);
reader_1.Feed(/*num_frames=*/2, controller_1->recommended_analog_level(),
reader_1.Feed(/*num_frames=*/2, controller_1->recommended_input_volume(),
/*gain_db=*/0,
/*speech_probability=*/0.49f, /*speech_level_dbfs=*/-42.0f,
*controller_1);
reader_2.Feed(/*num_frames=*/2, controller_2->recommended_analog_level(),
reader_2.Feed(/*num_frames=*/2, controller_2->recommended_input_volume(),
/*gain_db=*/0,
/*speech_probability=*/0.49f, /*speech_level_dbfs=*/-42.0f,
*controller_2);
ASSERT_EQ(controller_1->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_2->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_1->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_2->recommended_input_volume(), kInputVolume);
reader_1.Feed(
/*num_frames=*/7, controller_1->recommended_analog_level(), /*gain_db=*/0,
/*num_frames=*/7, controller_1->recommended_input_volume(), /*gain_db=*/0,
/*speech_probability=*/0.5f, /*speech_level_dbfs=*/-42.0f, *controller_1);
reader_2.Feed(
/*num_frames=*/7, controller_2->recommended_analog_level(), /*gain_db=*/0,
/*num_frames=*/7, controller_2->recommended_input_volume(), /*gain_db=*/0,
/*speech_probability=*/0.5f, /*speech_level_dbfs=*/-42.0f, *controller_2);
ASSERT_GT(controller_1->recommended_analog_level(), kInputVolume);
ASSERT_EQ(controller_2->recommended_analog_level(), kInputVolume);
ASSERT_GT(controller_1->recommended_input_volume(), kInputVolume);
ASSERT_EQ(controller_2->recommended_input_volume(), kInputVolume);
}
TEST(InputVolumeControllerTest,
@ -1432,7 +1432,7 @@ TEST(InputVolumeControllerTest,
reader.Feed(/*num_frames=*/14, kStartupVolume, /*gain_db=*/50,
kHighSpeechProbability,
/*speech_level_dbfs=*/-20.0f, *controller);
ASSERT_LT(controller->recommended_analog_level(), kStartupVolume);
ASSERT_LT(controller->recommended_input_volume(), kStartupVolume);
EXPECT_METRIC_THAT(
metrics::Samples(
"WebRTC.Audio.Apm.RecommendedInputVolume.OnChangeToMatchTarget"),
@ -1452,7 +1452,7 @@ TEST(InputVolumeControllerTest,
reader.Feed(/*num_frames=*/14, kStartupVolume, /*gain_db=*/-6,
kHighSpeechProbability,
/*speech_level_dbfs=*/-50.0f, *controller);
ASSERT_GT(controller->recommended_analog_level(), kStartupVolume);
ASSERT_GT(controller->recommended_input_volume(), kStartupVolume);
EXPECT_METRIC_THAT(
metrics::Samples(
"WebRTC.Audio.Apm.RecommendedInputVolume.OnChangeToMatchTarget"),
@ -1467,13 +1467,13 @@ TEST(InputVolumeControllerTest,
auto controller = CreateInputVolumeController();
controller->Initialize();
constexpr int kStartupVolume = 100;
controller->set_stream_analog_level(kStartupVolume);
controller->SetAppliedInputVolume(kStartupVolume);
// Trigger a downward volume change by inputting audio that does not clip and
// by passing a speech level above the target range.
reader.Feed(/*num_frames=*/14, kStartupVolume, /*gain_db=*/-6,
kHighSpeechProbability,
/*speech_level_dbfs=*/-5.0f, *controller);
ASSERT_LT(controller->recommended_analog_level(), kStartupVolume);
ASSERT_LT(controller->recommended_input_volume(), kStartupVolume);
EXPECT_METRIC_THAT(
metrics::Samples(
"WebRTC.Audio.Apm.RecommendedInputVolume.OnChangeToMatchTarget"),

4
modules/audio_processing/gain_controller2.cc
View File

@ -158,7 +158,7 @@ void GainController2::Analyze(int applied_input_volume,
if (input_volume_controller_) {
// TODO(bugs.webrtc.org/7494): Pass applied volume to `AnalyzePreProcess()`.
input_volume_controller_->set_stream_analog_level(applied_input_volume);
input_volume_controller_->SetAppliedInputVolume(applied_input_volume);
input_volume_controller_->AnalyzePreProcess(audio_buffer);
}
}
@ -166,7 +166,7 @@ void GainController2::Analyze(int applied_input_volume,
absl::optional<int> GainController2::GetRecommendedInputVolume() const {
return input_volume_controller_
? absl::optional<int>(
input_volume_controller_->recommended_analog_level())
input_volume_controller_->recommended_input_volume())
: absl::nullopt;
}