mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 22:00:47 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Reland "APM: rename AnalogGainStatsReporter to InputVolumeStatsReporter"

Browse source 
This reverts commit 6a18f06bd0.

Reason for revert: reverted by mistake

Original change's description:
> Revert "APM: rename `AnalogGainStatsReporter` to `InputVolumeStatsReporter`"
>
> This reverts commit b5319fabee.
>
> Reason for revert: audioproc_f crash 
>
> Original change's description:
> > APM: rename `AnalogGainStatsReporter` to `InputVolumeStatsReporter`
> >
> > Adopt the new naming convention, which replaces "analog gain" and
> > "mic level" with "input volume", in the input volume stats reporter.
> >
> > Bug: webrtc:7494
> > Change-Id: Ia24876151f51dd1dcc4e4f9db56c64d11ae3b442
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/279840
> > Reviewed-by: Hanna Silen <silen@webrtc.org>
> > Commit-Queue: Alessio Bazzica <alessiob@webrtc.org>
> > Cr-Commit-Position: refs/heads/main@{#38467}
>
> Bug: webrtc:7494
> Change-Id: Ia943a57c93fc77eb8450fab17961e60774e10f02
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/280600
> Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
> Commit-Queue: Alessio Bazzica <alessiob@webrtc.org>
> Auto-Submit: Alessio Bazzica <alessiob@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#38478}

Bug: webrtc:7494
Change-Id: I204133460dc119142f87695effce45e04426519f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/280582
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Alessio Bazzica <alessiob@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38479}
This commit is contained in:
Alessio Bazzica 2022-10-26 13:30:25 +00:00 committed by WebRTC LUCI CQ
parent 6a18f06bd0
commit c34a8c19c6
5 changed files with 117 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
modules/audio_processing/agc2/input_volume_stats_reporter.cc
View file

@ -20,9 +20,9 @@ namespace webrtc {
namespace { namespace {
constexpr int kFramesIn60Seconds = 6000; constexpr int kFramesIn60Seconds = 6000;
constexpr int kMinGain = 0; constexpr int kMinInputVolume = 0;
constexpr int kMaxGain = 255; constexpr int kMaxInputVolume = 255;
constexpr int kMaxUpdate = kMaxGain - kMinGain; constexpr int kMaxUpdate = kMaxInputVolume - kMinInputVolume;
float ComputeAverageUpdate(int sum_updates, int num_updates) { float ComputeAverageUpdate(int sum_updates, int num_updates) {
RTC_DCHECK_GE(sum_updates, 0); RTC_DCHECK_GE(sum_updates, 0);
@ -37,59 +37,50 @@ float ComputeAverageUpdate(int sum_updates, int num_updates) {
} }
} // namespace } // namespace
AnalogGainStatsReporter::AnalogGainStatsReporter() = default; InputVolumeStatsReporter::InputVolumeStatsReporter() = default;
AnalogGainStatsReporter::~AnalogGainStatsReporter() = default; InputVolumeStatsReporter::~InputVolumeStatsReporter() = default;
void AnalogGainStatsReporter::UpdateStatistics(int analog_mic_level) { void InputVolumeStatsReporter::UpdateStatistics(int input_volume) {
RTC_DCHECK_GE(analog_mic_level, kMinGain); RTC_DCHECK_GE(input_volume, kMinInputVolume);
RTC_DCHECK_LE(analog_mic_level, kMaxGain); RTC_DCHECK_LE(input_volume, kMaxInputVolume);
if (previous_analog_mic_level_.has_value() && if (previous_input_volume_.has_value() &&
analog_mic_level != previous_analog_mic_level_.value()) { input_volume != previous_input_volume_.value()) {
const int level_change = const int volume_change = input_volume - previous_input_volume_.value();
analog_mic_level - previous_analog_mic_level_.value(); if (volume_change < 0) {
if (level_change < 0) { ++volume_update_stats_.num_decreases;
++level_update_stats_.num_decreases; volume_update_stats_.sum_decreases -= volume_change;
level_update_stats_.sum_decreases -= level_change;
} else { } else {
++level_update_stats_.num_increases; ++volume_update_stats_.num_increases;
level_update_stats_.sum_increases += level_change; volume_update_stats_.sum_increases += volume_change;
} }
} }
// Periodically log analog gain change metrics. // Periodically log input volume change metrics.
if (++log_level_update_stats_counter_ >= kFramesIn60Seconds) { if (++log_volume_update_stats_counter_ >= kFramesIn60Seconds) {
LogLevelUpdateStats(); LogVolumeUpdateStats();
level_update_stats_ = {}; volume_update_stats_ = {};
log_level_update_stats_counter_ = 0; log_volume_update_stats_counter_ = 0;
} }
previous_analog_mic_level_ = analog_mic_level; previous_input_volume_ = input_volume;
} }
void AnalogGainStatsReporter::LogLevelUpdateStats() const { void InputVolumeStatsReporter::LogVolumeUpdateStats() const {
const float average_decrease = ComputeAverageUpdate( const float average_decrease = ComputeAverageUpdate(
level_update_stats_.sum_decreases, level_update_stats_.num_decreases); volume_update_stats_.sum_decreases, volume_update_stats_.num_decreases);
const float average_increase = ComputeAverageUpdate( const float average_increase = ComputeAverageUpdate(
level_update_stats_.sum_increases, level_update_stats_.num_increases); volume_update_stats_.sum_increases, volume_update_stats_.num_increases);
const int num_updates = const int num_updates =
level_update_stats_.num_decreases + level_update_stats_.num_increases; volume_update_stats_.num_decreases + volume_update_stats_.num_increases;
const float average_update = ComputeAverageUpdate( const float average_update = ComputeAverageUpdate(
level_update_stats_.sum_decreases + level_update_stats_.sum_increases, volume_update_stats_.sum_decreases + volume_update_stats_.sum_increases,
num_updates); num_updates);
RTC_DLOG(LS_INFO) << "Analog gain update rate: "
<< "num_updates=" << num_updates
<< ", num_decreases=" << level_update_stats_.num_decreases
<< ", num_increases=" << level_update_stats_.num_increases;
RTC_DLOG(LS_INFO) << "Analog gain update average: "
<< "average_update=" << average_update
<< ", average_decrease=" << average_decrease
<< ", average_increase=" << average_increase;
RTC_HISTOGRAM_COUNTS_LINEAR( RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainDecreaseRate", /*name=*/"WebRTC.Audio.ApmAnalogGainDecreaseRate",
/*sample=*/level_update_stats_.num_decreases, /*sample=*/volume_update_stats_.num_decreases,
/*min=*/1, /*min=*/1,
/*max=*/kFramesIn60Seconds, /*max=*/kFramesIn60Seconds,
/*bucket_count=*/50); /*bucket_count=*/50);
if (level_update_stats_.num_decreases > 0) { if (volume_update_stats_.num_decreases > 0) {
RTC_HISTOGRAM_COUNTS_LINEAR( RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainDecreaseAverage", /*name=*/"WebRTC.Audio.ApmAnalogGainDecreaseAverage",
/*sample=*/average_decrease, /*sample=*/average_decrease,
@ -99,11 +90,11 @@ void AnalogGainStatsReporter::LogLevelUpdateStats() const {
} }
RTC_HISTOGRAM_COUNTS_LINEAR( RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseRate", /*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseRate",
/*sample=*/level_update_stats_.num_increases, /*sample=*/volume_update_stats_.num_increases,
/*min=*/1, /*min=*/1,
/*max=*/kFramesIn60Seconds, /*max=*/kFramesIn60Seconds,
/*bucket_count=*/50); /*bucket_count=*/50);
if (level_update_stats_.num_increases > 0) { if (volume_update_stats_.num_increases > 0) {
RTC_HISTOGRAM_COUNTS_LINEAR( RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseAverage", /*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseAverage",
/*sample=*/average_increase, /*sample=*/average_increase,

60
modules/audio_processing/agc2/input_volume_stats_reporter.h
View file

@ -16,51 +16,49 @@
namespace webrtc { namespace webrtc {
// Analog gain statistics calculator. Computes aggregate stats based on the // Input volume statistics calculator. Computes aggregate stats based on the
// framewise mic levels processed in `UpdateStatistics()`. Periodically logs the // framewise input volume observed by `UpdateStatistics()`. Periodically logs
// statistics into a histogram. // the statistics into a histogram.
class AnalogGainStatsReporter { class InputVolumeStatsReporter {
public: public:
AnalogGainStatsReporter(); InputVolumeStatsReporter();
AnalogGainStatsReporter(const AnalogGainStatsReporter&) = delete; InputVolumeStatsReporter(const InputVolumeStatsReporter&) = delete;
AnalogGainStatsReporter operator=(const AnalogGainStatsReporter&) = delete; InputVolumeStatsReporter operator=(const InputVolumeStatsReporter&) = delete;
~AnalogGainStatsReporter(); ~InputVolumeStatsReporter();
// Updates the stats based on the `analog_mic_level`. Periodically logs the // Updates the stats based on `input_volume`. Periodically logs the stats into
// stats into a histogram. // a histogram.
void UpdateStatistics(int analog_mic_level); void UpdateStatistics(int input_volume);
private: private:
FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest,
CheckLevelUpdateStatsForEmptyStats); CheckVolumeUpdateStatsForEmptyStats);
FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest,
CheckLevelUpdateStatsAfterNoGainChange); CheckVolumeUpdateStatsAfterNoVolumeChange);
FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest,
CheckLevelUpdateStatsAfterGainIncrease); CheckVolumeUpdateStatsAfterVolumeIncrease);
FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest,
CheckLevelUpdateStatsAfterGainDecrease); CheckVolumeUpdateStatsAfterVolumeDecrease);
FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest,
CheckLevelUpdateStatsAfterReset); CheckVolumeUpdateStatsAfterReset);
// Stores analog gain update stats to enable calculation of update rate and // Stores input volume update stats to enable calculation of update rate and
// average update separately for gain increases and decreases. // average update separately for volume increases and decreases.
struct LevelUpdateStats { struct VolumeUpdateStats {
int num_decreases = 0; int num_decreases = 0;
int num_increases = 0; int num_increases = 0;
int sum_decreases = 0; int sum_decreases = 0;
int sum_increases = 0; int sum_increases = 0;
} level_update_stats_; } volume_update_stats_;
// Returns a copy of the stored statistics. Use only for testing. // Returns a copy of the stored statistics. Use only for testing.
const LevelUpdateStats level_update_stats() const { VolumeUpdateStats volume_update_stats() const { return volume_update_stats_; }
return level_update_stats_;
}
// Computes aggregate stat and logs them into a histogram. // Computes aggregate stat and logs them into a histogram.
void LogLevelUpdateStats() const; void LogVolumeUpdateStats() const;
int log_level_update_stats_counter_ = 0; int log_volume_update_stats_counter_ = 0;
absl::optional<int> previous_analog_mic_level_ = absl::nullopt; absl::optional<int> previous_input_volume_ = absl::nullopt;
}; };
} // namespace webrtc } // namespace webrtc

107
modules/audio_processing/agc2/input_volume_stats_reporter_unittest.cc
View file

@ -18,22 +18,22 @@ namespace {
constexpr int kFramesIn60Seconds = 6000; constexpr int kFramesIn60Seconds = 6000;
class AnalogGainStatsReporterTest : public ::testing::Test { class InputVolumeStatsReporterTest : public ::testing::Test {
public: public:
AnalogGainStatsReporterTest() {} InputVolumeStatsReporterTest() {}
protected: protected:
void SetUp() override { metrics::Reset(); } void SetUp() override { metrics::Reset(); }
}; };
TEST_F(AnalogGainStatsReporterTest, CheckLogLevelUpdateStatsEmpty) { TEST_F(InputVolumeStatsReporterTest, CheckLogVolumeUpdateStatsEmpty) {
AnalogGainStatsReporter stats_reporter; InputVolumeStatsReporter stats_reporter;
constexpr int kMicLevel = 10; constexpr int kInputVolume = 10;
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
// Update almost until the periodic logging and reset. // Update almost until the periodic logging and reset.
for (int i = 0; i < kFramesIn60Seconds - 2; i += 2) { for (int i = 0; i < kFramesIn60Seconds - 2; i += 2) {
stats_reporter.UpdateStatistics(kMicLevel + 2); stats_reporter.UpdateStatistics(kInputVolume + 2);
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
} }
EXPECT_METRIC_THAT(metrics::Samples("WebRTC.Audio.ApmAnalogGainUpdateRate"), EXPECT_METRIC_THAT(metrics::Samples("WebRTC.Audio.ApmAnalogGainUpdateRate"),
::testing::ElementsAre()); ::testing::ElementsAre());
@ -52,19 +52,19 @@ TEST_F(AnalogGainStatsReporterTest, CheckLogLevelUpdateStatsEmpty) {
::testing::ElementsAre()); ::testing::ElementsAre());
} }
TEST_F(AnalogGainStatsReporterTest, CheckLogLevelUpdateStatsNotEmpty) { TEST_F(InputVolumeStatsReporterTest, CheckLogVolumeUpdateStatsNotEmpty) {
AnalogGainStatsReporter stats_reporter; InputVolumeStatsReporter stats_reporter;
constexpr int kMicLevel = 10; constexpr int kInputVolume = 10;
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
// Update until periodic logging. // Update until periodic logging.
for (int i = 0; i < kFramesIn60Seconds; i += 2) { for (int i = 0; i < kFramesIn60Seconds; i += 2) {
stats_reporter.UpdateStatistics(kMicLevel + 2); stats_reporter.UpdateStatistics(kInputVolume + 2);
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
} }
// Update until periodic logging. // Update until periodic logging.
for (int i = 0; i < kFramesIn60Seconds; i += 2) { for (int i = 0; i < kFramesIn60Seconds; i += 2) {
stats_reporter.UpdateStatistics(kMicLevel + 3); stats_reporter.UpdateStatistics(kInputVolume + 3);
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
} }
EXPECT_METRIC_THAT( EXPECT_METRIC_THAT(
metrics::Samples("WebRTC.Audio.ApmAnalogGainUpdateRate"), metrics::Samples("WebRTC.Audio.ApmAnalogGainUpdateRate"),
@ -89,77 +89,80 @@ TEST_F(AnalogGainStatsReporterTest, CheckLogLevelUpdateStatsNotEmpty) {
} }
} // namespace } // namespace
TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsForEmptyStats) { TEST_F(InputVolumeStatsReporterTest, CheckVolumeUpdateStatsForEmptyStats) {
AnalogGainStatsReporter stats_reporter; InputVolumeStatsReporter stats_reporter;
const auto& update_stats = stats_reporter.level_update_stats(); const auto& update_stats = stats_reporter.volume_update_stats();
EXPECT_EQ(update_stats.num_decreases, 0); EXPECT_EQ(update_stats.num_decreases, 0);
EXPECT_EQ(update_stats.sum_decreases, 0); EXPECT_EQ(update_stats.sum_decreases, 0);
EXPECT_EQ(update_stats.num_increases, 0); EXPECT_EQ(update_stats.num_increases, 0);
EXPECT_EQ(update_stats.sum_increases, 0); EXPECT_EQ(update_stats.sum_increases, 0);
} }
TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterNoGainChange) { TEST_F(InputVolumeStatsReporterTest,
constexpr int kMicLevel = 10; CheckVolumeUpdateStatsAfterNoVolumeChange) {
AnalogGainStatsReporter stats_reporter; constexpr int kInputVolume = 10;
stats_reporter.UpdateStatistics(kMicLevel); InputVolumeStatsReporter stats_reporter;
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
const auto& update_stats = stats_reporter.level_update_stats(); stats_reporter.UpdateStatistics(kInputVolume);
const auto& update_stats = stats_reporter.volume_update_stats();
EXPECT_EQ(update_stats.num_decreases, 0); EXPECT_EQ(update_stats.num_decreases, 0);
EXPECT_EQ(update_stats.sum_decreases, 0); EXPECT_EQ(update_stats.sum_decreases, 0);
EXPECT_EQ(update_stats.num_increases, 0); EXPECT_EQ(update_stats.num_increases, 0);
EXPECT_EQ(update_stats.sum_increases, 0); EXPECT_EQ(update_stats.sum_increases, 0);
} }
TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterGainIncrease) { TEST_F(InputVolumeStatsReporterTest,
constexpr int kMicLevel = 10; CheckVolumeUpdateStatsAfterVolumeIncrease) {
AnalogGainStatsReporter stats_reporter; constexpr int kInputVolume = 10;
stats_reporter.UpdateStatistics(kMicLevel); InputVolumeStatsReporter stats_reporter;
stats_reporter.UpdateStatistics(kMicLevel + 4); stats_reporter.UpdateStatistics(kInputVolume);
stats_reporter.UpdateStatistics(kMicLevel + 5); stats_reporter.UpdateStatistics(kInputVolume + 4);
const auto& update_stats = stats_reporter.level_update_stats(); stats_reporter.UpdateStatistics(kInputVolume + 5);
const auto& update_stats = stats_reporter.volume_update_stats();
EXPECT_EQ(update_stats.num_decreases, 0); EXPECT_EQ(update_stats.num_decreases, 0);
EXPECT_EQ(update_stats.sum_decreases, 0); EXPECT_EQ(update_stats.sum_decreases, 0);
EXPECT_EQ(update_stats.num_increases, 2); EXPECT_EQ(update_stats.num_increases, 2);
EXPECT_EQ(update_stats.sum_increases, 5); EXPECT_EQ(update_stats.sum_increases, 5);
} }
TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterGainDecrease) { TEST_F(InputVolumeStatsReporterTest,
constexpr int kMicLevel = 10; CheckVolumeUpdateStatsAfterVolumeDecrease) {
AnalogGainStatsReporter stats_reporter; constexpr int kInputVolume = 10;
stats_reporter.UpdateStatistics(kMicLevel); InputVolumeStatsReporter stats_reporter;
stats_reporter.UpdateStatistics(kMicLevel - 4); stats_reporter.UpdateStatistics(kInputVolume);
stats_reporter.UpdateStatistics(kMicLevel - 5); stats_reporter.UpdateStatistics(kInputVolume - 4);
const auto& stats_update = stats_reporter.level_update_stats(); stats_reporter.UpdateStatistics(kInputVolume - 5);
const auto& stats_update = stats_reporter.volume_update_stats();
EXPECT_EQ(stats_update.num_decreases, 2); EXPECT_EQ(stats_update.num_decreases, 2);
EXPECT_EQ(stats_update.sum_decreases, 5); EXPECT_EQ(stats_update.sum_decreases, 5);
EXPECT_EQ(stats_update.num_increases, 0); EXPECT_EQ(stats_update.num_increases, 0);
EXPECT_EQ(stats_update.sum_increases, 0); EXPECT_EQ(stats_update.sum_increases, 0);
} }
TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterReset) { TEST_F(InputVolumeStatsReporterTest, CheckVolumeUpdateStatsAfterReset) {
AnalogGainStatsReporter stats_reporter; InputVolumeStatsReporter stats_reporter;
constexpr int kMicLevel = 10; constexpr int kInputVolume = 10;
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
// Update until the periodic reset. // Update until the periodic reset.
for (int i = 0; i < kFramesIn60Seconds - 2; i += 2) { for (int i = 0; i < kFramesIn60Seconds - 2; i += 2) {
stats_reporter.UpdateStatistics(kMicLevel + 2); stats_reporter.UpdateStatistics(kInputVolume + 2);
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
} }
const auto& stats_before_reset = stats_reporter.level_update_stats(); const auto& stats_before_reset = stats_reporter.volume_update_stats();
EXPECT_EQ(stats_before_reset.num_decreases, kFramesIn60Seconds / 2 - 1); EXPECT_EQ(stats_before_reset.num_decreases, kFramesIn60Seconds / 2 - 1);
EXPECT_EQ(stats_before_reset.sum_decreases, kFramesIn60Seconds - 2); EXPECT_EQ(stats_before_reset.sum_decreases, kFramesIn60Seconds - 2);
EXPECT_EQ(stats_before_reset.num_increases, kFramesIn60Seconds / 2 - 1); EXPECT_EQ(stats_before_reset.num_increases, kFramesIn60Seconds / 2 - 1);
EXPECT_EQ(stats_before_reset.sum_increases, kFramesIn60Seconds - 2); EXPECT_EQ(stats_before_reset.sum_increases, kFramesIn60Seconds - 2);
stats_reporter.UpdateStatistics(kMicLevel + 2); stats_reporter.UpdateStatistics(kInputVolume + 2);
const auto& stats_during_reset = stats_reporter.level_update_stats(); const auto& stats_during_reset = stats_reporter.volume_update_stats();
EXPECT_EQ(stats_during_reset.num_decreases, 0); EXPECT_EQ(stats_during_reset.num_decreases, 0);
EXPECT_EQ(stats_during_reset.sum_decreases, 0); EXPECT_EQ(stats_during_reset.sum_decreases, 0);
EXPECT_EQ(stats_during_reset.num_increases, 0); EXPECT_EQ(stats_during_reset.num_increases, 0);
EXPECT_EQ(stats_during_reset.sum_increases, 0); EXPECT_EQ(stats_during_reset.sum_increases, 0);
stats_reporter.UpdateStatistics(kMicLevel); stats_reporter.UpdateStatistics(kInputVolume);
stats_reporter.UpdateStatistics(kMicLevel + 3); stats_reporter.UpdateStatistics(kInputVolume + 3);
const auto& stats_after_reset = stats_reporter.level_update_stats(); const auto& stats_after_reset = stats_reporter.volume_update_stats();
EXPECT_EQ(stats_after_reset.num_decreases, 1); EXPECT_EQ(stats_after_reset.num_decreases, 1);
EXPECT_EQ(stats_after_reset.sum_decreases, 2); EXPECT_EQ(stats_after_reset.sum_decreases, 2);
EXPECT_EQ(stats_after_reset.num_increases, 1); EXPECT_EQ(stats_after_reset.num_increases, 1);

3
modules/audio_processing/audio_processing_impl.cc
View file

@ -1131,8 +1131,7 @@ int AudioProcessingImpl::ProcessCaptureStreamLocked() {
} }
if (capture_.applied_input_volume.has_value()) { if (capture_.applied_input_volume.has_value()) {
// Log the applied input volume only when available. applied_input_volume_stats_reporter_.UpdateStatistics(
input_volume_stats_reporter_.UpdateStatistics(
*capture_.applied_input_volume); *capture_.applied_input_volume);
} }

2
modules/audio_processing/audio_processing_impl.h
View file

@ -539,7 +539,7 @@ class AudioProcessingImpl : public AudioProcessing {
RmsLevel capture_output_rms_ RTC_GUARDED_BY(mutex_capture_); RmsLevel capture_output_rms_ RTC_GUARDED_BY(mutex_capture_);
int capture_rms_interval_counter_ RTC_GUARDED_BY(mutex_capture_) = 0; int capture_rms_interval_counter_ RTC_GUARDED_BY(mutex_capture_) = 0;
AnalogGainStatsReporter input_volume_stats_reporter_ InputVolumeStatsReporter applied_input_volume_stats_reporter_
RTC_GUARDED_BY(mutex_capture_); RTC_GUARDED_BY(mutex_capture_);
// Lock protection not needed. // Lock protection not needed.