mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +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 {
constexpr int kFramesIn60Seconds = 6000;
constexpr int kMinGain = 0;
constexpr int kMaxGain = 255;
constexpr int kMaxUpdate = kMaxGain - kMinGain;
constexpr int kMinInputVolume = 0;
constexpr int kMaxInputVolume = 255;
constexpr int kMaxUpdate = kMaxInputVolume - kMinInputVolume;
float ComputeAverageUpdate(int sum_updates, int num_updates) {
RTC_DCHECK_GE(sum_updates, 0);
@ -37,59 +37,50 @@ float ComputeAverageUpdate(int sum_updates, int num_updates) {
}
} // namespace
AnalogGainStatsReporter::AnalogGainStatsReporter() = default;
InputVolumeStatsReporter::InputVolumeStatsReporter() = default;
AnalogGainStatsReporter::~AnalogGainStatsReporter() = default;
InputVolumeStatsReporter::~InputVolumeStatsReporter() = default;
void AnalogGainStatsReporter::UpdateStatistics(int analog_mic_level) {
RTC_DCHECK_GE(analog_mic_level, kMinGain);
RTC_DCHECK_LE(analog_mic_level, kMaxGain);
if (previous_analog_mic_level_.has_value() &&
analog_mic_level != previous_analog_mic_level_.value()) {
const int level_change =
analog_mic_level - previous_analog_mic_level_.value();
if (level_change < 0) {
++level_update_stats_.num_decreases;
level_update_stats_.sum_decreases -= level_change;
void InputVolumeStatsReporter::UpdateStatistics(int input_volume) {
RTC_DCHECK_GE(input_volume, kMinInputVolume);
RTC_DCHECK_LE(input_volume, kMaxInputVolume);
if (previous_input_volume_.has_value() &&
input_volume != previous_input_volume_.value()) {
const int volume_change = input_volume - previous_input_volume_.value();
if (volume_change < 0) {
++volume_update_stats_.num_decreases;
volume_update_stats_.sum_decreases -= volume_change;
} else {
++level_update_stats_.num_increases;
level_update_stats_.sum_increases += level_change;
++volume_update_stats_.num_increases;
volume_update_stats_.sum_increases += volume_change;
}
}
// Periodically log analog gain change metrics.
if (++log_level_update_stats_counter_ >= kFramesIn60Seconds) {
LogLevelUpdateStats();
level_update_stats_ = {};
log_level_update_stats_counter_ = 0;
// Periodically log input volume change metrics.
if (++log_volume_update_stats_counter_ >= kFramesIn60Seconds) {
LogVolumeUpdateStats();
volume_update_stats_ = {};
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(
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(
level_update_stats_.sum_increases, level_update_stats_.num_increases);
volume_update_stats_.sum_increases, volume_update_stats_.num_increases);
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(
level_update_stats_.sum_decreases + level_update_stats_.sum_increases,
volume_update_stats_.sum_decreases + volume_update_stats_.sum_increases,
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(
/*name=*/"WebRTC.Audio.ApmAnalogGainDecreaseRate",
/*sample=*/level_update_stats_.num_decreases,
/*sample=*/volume_update_stats_.num_decreases,
/*min=*/1,
/*max=*/kFramesIn60Seconds,
/*bucket_count=*/50);
if (level_update_stats_.num_decreases > 0) {
if (volume_update_stats_.num_decreases > 0) {
RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainDecreaseAverage",
/*sample=*/average_decrease,
@ -99,11 +90,11 @@ void AnalogGainStatsReporter::LogLevelUpdateStats() const {
}
RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseRate",
/*sample=*/level_update_stats_.num_increases,
/*sample=*/volume_update_stats_.num_increases,
/*min=*/1,
/*max=*/kFramesIn60Seconds,
/*bucket_count=*/50);
if (level_update_stats_.num_increases > 0) {
if (volume_update_stats_.num_increases > 0) {
RTC_HISTOGRAM_COUNTS_LINEAR(
/*name=*/"WebRTC.Audio.ApmAnalogGainIncreaseAverage",
/*sample=*/average_increase,

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

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

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

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