zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "APM: rename AnalogGainStatsReporter to InputVolumeStatsReporter"

Browse Source 
This reverts commit b5319fabeeda4ffbf58f28f4ee3d5c7c3868fb3b.

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}
This commit is contained in:
Alessio Bazzica
2022-10-26 13:23:46 +00:00
committed by WebRTC LUCI CQ
parent 48a0c1a860
commit 6a18f06bd0
5 changed files with 126 additions and 117 deletions
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 kMinInputVolume = 0; constexpr int kMinGain = 0;
constexpr int kMaxInputVolume = 255; constexpr int kMaxGain = 255;
constexpr int kMaxUpdate = kMaxInputVolume - kMinInputVolume; constexpr int kMaxUpdate = kMaxGain - kMinGain;
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,50 +37,59 @@ float ComputeAverageUpdate(int sum_updates, int num_updates) {
} }
} // namespace } // namespace
InputVolumeStatsReporter::InputVolumeStatsReporter() = default; AnalogGainStatsReporter::AnalogGainStatsReporter() = default;
InputVolumeStatsReporter::~InputVolumeStatsReporter() = default; AnalogGainStatsReporter::~AnalogGainStatsReporter() = default;
void InputVolumeStatsReporter::UpdateStatistics(int input_volume) { void AnalogGainStatsReporter::UpdateStatistics(int analog_mic_level) {
RTC_DCHECK_GE(input_volume, kMinInputVolume); RTC_DCHECK_GE(analog_mic_level, kMinGain);
RTC_DCHECK_LE(input_volume, kMaxInputVolume); RTC_DCHECK_LE(analog_mic_level, kMaxGain);
if (previous_input_volume_.has_value() && if (previous_analog_mic_level_.has_value() &&
input_volume != previous_input_volume_.value()) { analog_mic_level != previous_analog_mic_level_.value()) {
const int volume_change = input_volume - previous_input_volume_.value(); const int level_change =
if (volume_change < 0) { analog_mic_level - previous_analog_mic_level_.value();
++volume_update_stats_.num_decreases; if (level_change < 0) {
volume_update_stats_.sum_decreases -= volume_change; ++level_update_stats_.num_decreases;
level_update_stats_.sum_decreases -= level_change;
} else { } else {
++volume_update_stats_.num_increases; ++level_update_stats_.num_increases;
volume_update_stats_.sum_increases += volume_change; level_update_stats_.sum_increases += level_change;
} }
} }
// Periodically log input volume change metrics. // Periodically log analog gain change metrics.
if (++log_volume_update_stats_counter_ >= kFramesIn60Seconds) { if (++log_level_update_stats_counter_ >= kFramesIn60Seconds) {
LogVolumeUpdateStats(); LogLevelUpdateStats();
volume_update_stats_ = {}; level_update_stats_ = {};
log_volume_update_stats_counter_ = 0; log_level_update_stats_counter_ = 0;
} }
previous_input_volume_ = input_volume; previous_analog_mic_level_ = analog_mic_level;
} }
void InputVolumeStatsReporter::LogVolumeUpdateStats() const { void AnalogGainStatsReporter::LogLevelUpdateStats() const {
const float average_decrease = ComputeAverageUpdate( const float average_decrease = ComputeAverageUpdate(
volume_update_stats_.sum_decreases, volume_update_stats_.num_decreases); level_update_stats_.sum_decreases, level_update_stats_.num_decreases);
const float average_increase = ComputeAverageUpdate( const float average_increase = ComputeAverageUpdate(
volume_update_stats_.sum_increases, volume_update_stats_.num_increases); level_update_stats_.sum_increases, level_update_stats_.num_increases);
const int num_updates = const int num_updates =
volume_update_stats_.num_decreases + volume_update_stats_.num_increases; level_update_stats_.num_decreases + level_update_stats_.num_increases;
const float average_update = ComputeAverageUpdate( const float average_update = ComputeAverageUpdate(
volume_update_stats_.sum_decreases + volume_update_stats_.sum_increases, level_update_stats_.sum_decreases + level_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=*/volume_update_stats_.num_decreases, /*sample=*/level_update_stats_.num_decreases,
/*min=*/1, /*min=*/1,
/*max=*/kFramesIn60Seconds, /*max=*/kFramesIn60Seconds,
/*bucket_count=*/50); /*bucket_count=*/50);
if (volume_update_stats_.num_decreases > 0) { if (level_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,
@ -90,11 +99,11 @@ void InputVolumeStatsReporter::LogVolumeUpdateStats() const {
} }
RTC_HISTOGRAM_COUNTS_LINEAR( RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseRate", /*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseRate",
/*sample=*/volume_update_stats_.num_increases, /*sample=*/level_update_stats_.num_increases,
/*min=*/1, /*min=*/1,
/*max=*/kFramesIn60Seconds, /*max=*/kFramesIn60Seconds,
/*bucket_count=*/50); /*bucket_count=*/50);
if (volume_update_stats_.num_increases > 0) { if (level_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,49 +16,51 @@
namespace webrtc { namespace webrtc {
// Input volume statistics calculator. Computes aggregate stats based on the // Analog gain statistics calculator. Computes aggregate stats based on the
// framewise input volume observed by `UpdateStatistics()`. Periodically logs // framewise mic levels processed in `UpdateStatistics()`. Periodically logs the
// the statistics into a histogram. // statistics into a histogram.
class InputVolumeStatsReporter { class AnalogGainStatsReporter {
public: public:
InputVolumeStatsReporter(); AnalogGainStatsReporter();
InputVolumeStatsReporter(const InputVolumeStatsReporter&) = delete; AnalogGainStatsReporter(const AnalogGainStatsReporter&) = delete;
InputVolumeStatsReporter operator=(const InputVolumeStatsReporter&) = delete; AnalogGainStatsReporter operator=(const AnalogGainStatsReporter&) = delete;
~InputVolumeStatsReporter(); ~AnalogGainStatsReporter();
// Updates the stats based on `input_volume`. Periodically logs the stats into // Updates the stats based on the `analog_mic_level`. Periodically logs the
// a histogram. // stats into a histogram.
void UpdateStatistics(int input_volume); void UpdateStatistics(int analog_mic_level);
private: private:
FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest,
CheckVolumeUpdateStatsForEmptyStats); CheckLevelUpdateStatsForEmptyStats);
FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest,
CheckVolumeUpdateStatsAfterNoVolumeChange); CheckLevelUpdateStatsAfterNoGainChange);
FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest,
CheckVolumeUpdateStatsAfterVolumeIncrease); CheckLevelUpdateStatsAfterGainIncrease);
FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest,
CheckVolumeUpdateStatsAfterVolumeDecrease); CheckLevelUpdateStatsAfterGainDecrease);
FRIEND_TEST_ALL_PREFIXES(InputVolumeStatsReporterTest, FRIEND_TEST_ALL_PREFIXES(AnalogGainStatsReporterTest,
CheckVolumeUpdateStatsAfterReset); CheckLevelUpdateStatsAfterReset);
// Stores input volume update stats to enable calculation of update rate and // Stores analog gain update stats to enable calculation of update rate and
// average update separately for volume increases and decreases. // average update separately for gain increases and decreases.
struct VolumeUpdateStats { struct LevelUpdateStats {
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;
} volume_update_stats_; } level_update_stats_;
// Returns a copy of the stored statistics. Use only for testing. // Returns a copy of the stored statistics. Use only for testing.
VolumeUpdateStats volume_update_stats() const { return volume_update_stats_; } const LevelUpdateStats level_update_stats() const {
return level_update_stats_;
}
// Computes aggregate stat and logs them into a histogram. // Computes aggregate stat and logs them into a histogram.
void LogVolumeUpdateStats() const; void LogLevelUpdateStats() const;
int log_volume_update_stats_counter_ = 0; int log_level_update_stats_counter_ = 0;
absl::optional<int> previous_input_volume_ = absl::nullopt; absl::optional<int> previous_analog_mic_level_ = 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 InputVolumeStatsReporterTest : public ::testing::Test { class AnalogGainStatsReporterTest : public ::testing::Test {
public: public:
InputVolumeStatsReporterTest() {} AnalogGainStatsReporterTest() {}
protected: protected:
void SetUp() override { metrics::Reset(); } void SetUp() override { metrics::Reset(); }
}; };
TEST_F(InputVolumeStatsReporterTest, CheckLogVolumeUpdateStatsEmpty) { TEST_F(AnalogGainStatsReporterTest, CheckLogLevelUpdateStatsEmpty) {
InputVolumeStatsReporter stats_reporter; AnalogGainStatsReporter stats_reporter;
constexpr int kInputVolume = 10; constexpr int kMicLevel = 10;
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
// 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(kInputVolume + 2); stats_reporter.UpdateStatistics(kMicLevel + 2);
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
} }
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(InputVolumeStatsReporterTest, CheckLogVolumeUpdateStatsEmpty) {
::testing::ElementsAre()); ::testing::ElementsAre());
} }
TEST_F(InputVolumeStatsReporterTest, CheckLogVolumeUpdateStatsNotEmpty) { TEST_F(AnalogGainStatsReporterTest, CheckLogLevelUpdateStatsNotEmpty) {
InputVolumeStatsReporter stats_reporter; AnalogGainStatsReporter stats_reporter;
constexpr int kInputVolume = 10; constexpr int kMicLevel = 10;
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
// 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(kInputVolume + 2); stats_reporter.UpdateStatistics(kMicLevel + 2);
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
} }
// 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(kInputVolume + 3); stats_reporter.UpdateStatistics(kMicLevel + 3);
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
} }
EXPECT_METRIC_THAT( EXPECT_METRIC_THAT(
metrics::Samples("WebRTC.Audio.ApmAnalogGainUpdateRate"), metrics::Samples("WebRTC.Audio.ApmAnalogGainUpdateRate"),
@ -89,80 +89,77 @@ TEST_F(InputVolumeStatsReporterTest, CheckLogVolumeUpdateStatsNotEmpty) {
} }
} // namespace } // namespace
TEST_F(InputVolumeStatsReporterTest, CheckVolumeUpdateStatsForEmptyStats) { TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsForEmptyStats) {
InputVolumeStatsReporter stats_reporter; AnalogGainStatsReporter stats_reporter;
const auto& update_stats = stats_reporter.volume_update_stats(); const auto& update_stats = stats_reporter.level_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(InputVolumeStatsReporterTest, TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterNoGainChange) {
CheckVolumeUpdateStatsAfterNoVolumeChange) { constexpr int kMicLevel = 10;
constexpr int kInputVolume = 10; AnalogGainStatsReporter stats_reporter;
InputVolumeStatsReporter stats_reporter; stats_reporter.UpdateStatistics(kMicLevel);
stats_reporter.UpdateStatistics(kInputVolume); 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();
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(InputVolumeStatsReporterTest, TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterGainIncrease) {
CheckVolumeUpdateStatsAfterVolumeIncrease) { constexpr int kMicLevel = 10;
constexpr int kInputVolume = 10; AnalogGainStatsReporter stats_reporter;
InputVolumeStatsReporter stats_reporter; stats_reporter.UpdateStatistics(kMicLevel);
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel + 4);
stats_reporter.UpdateStatistics(kInputVolume + 4); stats_reporter.UpdateStatistics(kMicLevel + 5);
stats_reporter.UpdateStatistics(kInputVolume + 5); 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, 2); EXPECT_EQ(update_stats.num_increases, 2);
EXPECT_EQ(update_stats.sum_increases, 5); EXPECT_EQ(update_stats.sum_increases, 5);
} }
TEST_F(InputVolumeStatsReporterTest, TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterGainDecrease) {
CheckVolumeUpdateStatsAfterVolumeDecrease) { constexpr int kMicLevel = 10;
constexpr int kInputVolume = 10; AnalogGainStatsReporter stats_reporter;
InputVolumeStatsReporter stats_reporter; stats_reporter.UpdateStatistics(kMicLevel);
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel - 4);
stats_reporter.UpdateStatistics(kInputVolume - 4); stats_reporter.UpdateStatistics(kMicLevel - 5);
stats_reporter.UpdateStatistics(kInputVolume - 5); const auto& stats_update = stats_reporter.level_update_stats();
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(InputVolumeStatsReporterTest, CheckVolumeUpdateStatsAfterReset) { TEST_F(AnalogGainStatsReporterTest, CheckLevelUpdateStatsAfterReset) {
InputVolumeStatsReporter stats_reporter; AnalogGainStatsReporter stats_reporter;
constexpr int kInputVolume = 10; constexpr int kMicLevel = 10;
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
// 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(kInputVolume + 2); stats_reporter.UpdateStatistics(kMicLevel + 2);
stats_reporter.UpdateStatistics(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
} }
const auto& stats_before_reset = stats_reporter.volume_update_stats(); const auto& stats_before_reset = stats_reporter.level_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(kInputVolume + 2); stats_reporter.UpdateStatistics(kMicLevel + 2);
const auto& stats_during_reset = stats_reporter.volume_update_stats(); const auto& stats_during_reset = stats_reporter.level_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(kInputVolume); stats_reporter.UpdateStatistics(kMicLevel);
stats_reporter.UpdateStatistics(kInputVolume + 3); stats_reporter.UpdateStatistics(kMicLevel + 3);
const auto& stats_after_reset = stats_reporter.volume_update_stats(); const auto& stats_after_reset = stats_reporter.level_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,7 +1131,8 @@ int AudioProcessingImpl::ProcessCaptureStreamLocked() {
} }
if (capture_.applied_input_volume.has_value()) { if (capture_.applied_input_volume.has_value()) {
applied_input_volume_stats_reporter_.UpdateStatistics( // Log the applied input volume only when available.
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;
InputVolumeStatsReporter applied_input_volume_stats_reporter_ AnalogGainStatsReporter input_volume_stats_reporter_
RTC_GUARDED_BY(mutex_capture_); RTC_GUARDED_BY(mutex_capture_);
// Lock protection not needed. // Lock protection not needed.