InputVolumeController: Restrict the application of min input volume
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}
diff --git a/modules/audio_processing/agc2/input_volume_controller.cc b/modules/audio_processing/agc2/input_volume_controller.cc
index 46962ae..5cfb3c6 100644
--- a/modules/audio_processing/agc2/input_volume_controller.cc
+++ b/modules/audio_processing/agc2/input_volume_controller.cc
@@ -551,7 +551,9 @@
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 @@
}
// 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_);
}
diff --git a/modules/audio_processing/agc2/input_volume_controller.h b/modules/audio_processing/agc2/input_volume_controller.h
index cfad277..f1b1fa2 100644
--- a/modules/audio_processing/agc2/input_volume_controller.h
+++ b/modules/audio_processing/agc2/input_volume_controller.h
@@ -82,7 +82,7 @@
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 @@
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 @@
// 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_;
diff --git a/modules/audio_processing/agc2/input_volume_controller_unittest.cc b/modules/audio_processing/agc2/input_volume_controller_unittest.cc
index 2934987..dc85477 100644
--- a/modules/audio_processing/agc2/input_volume_controller_unittest.cc
+++ b/modules/audio_processing/agc2/input_volume_controller_unittest.cc
@@ -216,10 +216,10 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
*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 @@
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 @@
/*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 @@
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 @@
*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 @@
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 @@
/*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 @@
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 @@
/*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 @@
/*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 @@
/*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 @@
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 @@
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 @@
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"),
diff --git a/modules/audio_processing/gain_controller2.cc b/modules/audio_processing/gain_controller2.cc
index cdb259a..058f77b 100644
--- a/modules/audio_processing/gain_controller2.cc
+++ b/modules/audio_processing/gain_controller2.cc
@@ -158,7 +158,7 @@
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 @@
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;
}
