blob: 0cd67ca0a389b49aa6888512666d45f49765b9ce [file] [log] [blame]
/*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/audio_processing/agc/agc_manager_direct.h"
#include <algorithm>
#include <cmath>
#include "common_audio/include/audio_util.h"
#include "modules/audio_processing/agc/gain_control.h"
#include "modules/audio_processing/agc/gain_map_internal.h"
#include "modules/audio_processing/include/audio_frame_view.h"
#include "rtc_base/atomic_ops.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_minmax.h"
#include "system_wrappers/include/field_trial.h"
#include "system_wrappers/include/metrics.h"
namespace webrtc {
namespace {
// Amount of error we tolerate in the microphone level (presumably due to OS
// quantization) before we assume the user has manually adjusted the microphone.
constexpr int kLevelQuantizationSlack = 25;
constexpr int kDefaultCompressionGain = 7;
constexpr int kMaxCompressionGain = 12;
constexpr int kMinCompressionGain = 2;
// Controls the rate of compression changes towards the target.
constexpr float kCompressionGainStep = 0.05f;
constexpr int kMaxMicLevel = 255;
static_assert(kGainMapSize > kMaxMicLevel, "gain map too small");
constexpr int kMinMicLevel = 12;
// Prevent very large microphone level changes.
constexpr int kMaxResidualGainChange = 15;
// Maximum additional gain allowed to compensate for microphone level
// restrictions from clipping events.
constexpr int kSurplusCompressionGain = 6;
// History size for the clipping predictor evaluator (unit: number of 10 ms
// frames).
constexpr int kClippingPredictorEvaluatorHistorySize = 32;
using ClippingPredictorConfig = AudioProcessing::Config::GainController1::
AnalogGainController::ClippingPredictor;
// Returns whether a fall-back solution to choose the maximum level should be
// chosen.
bool UseMaxAnalogChannelLevel() {
return field_trial::IsEnabled("WebRTC-UseMaxAnalogAgcChannelLevel");
}
// Returns kMinMicLevel if no field trial exists or if it has been disabled.
// Returns a value between 0 and 255 depending on the field-trial string.
// Example: 'WebRTC-Audio-AgcMinMicLevelExperiment/Enabled-80' => returns 80.
int GetMinMicLevel() {
RTC_LOG(LS_INFO) << "[agc] GetMinMicLevel";
constexpr char kMinMicLevelFieldTrial[] =
"WebRTC-Audio-AgcMinMicLevelExperiment";
if (!webrtc::field_trial::IsEnabled(kMinMicLevelFieldTrial)) {
RTC_LOG(LS_INFO) << "[agc] Using default min mic level: " << kMinMicLevel;
return kMinMicLevel;
}
const auto field_trial_string =
webrtc::field_trial::FindFullName(kMinMicLevelFieldTrial);
int min_mic_level = -1;
sscanf(field_trial_string.c_str(), "Enabled-%d", &min_mic_level);
if (min_mic_level >= 0 && min_mic_level <= 255) {
RTC_LOG(LS_INFO) << "[agc] Experimental min mic level: " << min_mic_level;
return min_mic_level;
} else {
RTC_LOG(LS_WARNING) << "[agc] Invalid parameter for "
<< kMinMicLevelFieldTrial << ", ignored.";
return kMinMicLevel;
}
}
int ClampLevel(int mic_level, int min_mic_level) {
return rtc::SafeClamp(mic_level, min_mic_level, kMaxMicLevel);
}
int LevelFromGainError(int gain_error, int level, int min_mic_level) {
RTC_DCHECK_GE(level, 0);
RTC_DCHECK_LE(level, kMaxMicLevel);
if (gain_error == 0) {
return level;
}
int new_level = level;
if (gain_error > 0) {
while (kGainMap[new_level] - kGainMap[level] < gain_error &&
new_level < kMaxMicLevel) {
++new_level;
}
} else {
while (kGainMap[new_level] - kGainMap[level] > gain_error &&
new_level > min_mic_level) {
--new_level;
}
}
return new_level;
}
// Returns the proportion of samples in the buffer which are at full-scale
// (and presumably clipped).
float ComputeClippedRatio(const float* const* audio,
size_t num_channels,
size_t samples_per_channel) {
RTC_DCHECK_GT(samples_per_channel, 0);
int num_clipped = 0;
for (size_t ch = 0; ch < num_channels; ++ch) {
int num_clipped_in_ch = 0;
for (size_t i = 0; i < samples_per_channel; ++i) {
RTC_DCHECK(audio[ch]);
if (audio[ch][i] >= 32767.f || audio[ch][i] <= -32768.f) {
++num_clipped_in_ch;
}
}
num_clipped = std::max(num_clipped, num_clipped_in_ch);
}
return static_cast<float>(num_clipped) / (samples_per_channel);
}
void LogClippingPredictorMetrics(const ClippingPredictorEvaluator& evaluator) {
RTC_LOG(LS_INFO) << "Clipping predictor metrics: TP "
<< evaluator.true_positives() << " TN "
<< evaluator.true_negatives() << " FP "
<< evaluator.false_positives() << " FN "
<< evaluator.false_negatives();
const float precision_denominator =
evaluator.true_positives() + evaluator.false_positives();
const float recall_denominator =
evaluator.true_positives() + evaluator.false_negatives();
if (precision_denominator > 0 && recall_denominator > 0) {
const float precision = evaluator.true_positives() / precision_denominator;
const float recall = evaluator.true_positives() / recall_denominator;
RTC_LOG(LS_INFO) << "Clipping predictor metrics: P " << precision << " R "
<< recall;
const float f1_score_denominator = precision + recall;
if (f1_score_denominator > 0.0f) {
const float f1_score = 2 * precision * recall / f1_score_denominator;
RTC_LOG(LS_INFO) << "Clipping predictor metrics: F1 " << f1_score;
RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc.ClippingPredictor.F1Score",
std::round(f1_score * 100.0f), /*min=*/0,
/*max=*/100,
/*bucket_count=*/50);
}
}
}
void LogClippingMetrics(int clipping_rate) {
RTC_LOG(LS_INFO) << "Input clipping rate: " << clipping_rate << "%";
RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc.InputClippingRate",
clipping_rate, /*min=*/0, /*max=*/100,
/*bucket_count=*/50);
}
} // namespace
MonoAgc::MonoAgc(ApmDataDumper* data_dumper,
int startup_min_level,
int clipped_level_min,
bool disable_digital_adaptive,
int min_mic_level)
: min_mic_level_(min_mic_level),
disable_digital_adaptive_(disable_digital_adaptive),
agc_(std::make_unique<Agc>()),
max_level_(kMaxMicLevel),
max_compression_gain_(kMaxCompressionGain),
target_compression_(kDefaultCompressionGain),
compression_(target_compression_),
compression_accumulator_(compression_),
startup_min_level_(ClampLevel(startup_min_level, min_mic_level_)),
clipped_level_min_(clipped_level_min) {}
MonoAgc::~MonoAgc() = default;
void MonoAgc::Initialize() {
max_level_ = kMaxMicLevel;
max_compression_gain_ = kMaxCompressionGain;
target_compression_ = disable_digital_adaptive_ ? 0 : kDefaultCompressionGain;
compression_ = disable_digital_adaptive_ ? 0 : target_compression_;
compression_accumulator_ = compression_;
capture_output_used_ = true;
check_volume_on_next_process_ = true;
}
void MonoAgc::Process(const int16_t* audio,
size_t samples_per_channel,
int sample_rate_hz) {
new_compression_to_set_ = absl::nullopt;
if (check_volume_on_next_process_) {
check_volume_on_next_process_ = false;
// We have to wait until the first process call to check the volume,
// because Chromium doesn't guarantee it to be valid any earlier.
CheckVolumeAndReset();
}
agc_->Process(audio, samples_per_channel, sample_rate_hz);
UpdateGain();
if (!disable_digital_adaptive_) {
UpdateCompressor();
}
}
void MonoAgc::HandleClipping(int clipped_level_step) {
// Always decrease the maximum level, even if the current level is below
// threshold.
SetMaxLevel(std::max(clipped_level_min_, max_level_ - clipped_level_step));
if (log_to_histograms_) {
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.AgcClippingAdjustmentAllowed",
level_ - clipped_level_step >= clipped_level_min_);
}
if (level_ > clipped_level_min_) {
// Don't try to adjust the level if we're already below the limit. As
// a consequence, if the user has brought the level above the limit, we
// will still not react until the postproc updates the level.
SetLevel(std::max(clipped_level_min_, level_ - clipped_level_step));
// Reset the AGCs for all channels since the level has changed.
agc_->Reset();
}
}
void MonoAgc::SetLevel(int new_level) {
int voe_level = stream_analog_level_;
if (voe_level == 0) {
RTC_DLOG(LS_INFO)
<< "[agc] VolumeCallbacks returned level=0, taking no action.";
return;
}
if (voe_level < 0 || voe_level > kMaxMicLevel) {
RTC_LOG(LS_ERROR) << "VolumeCallbacks returned an invalid level="
<< voe_level;
return;
}
if (voe_level > level_ + kLevelQuantizationSlack ||
voe_level < level_ - kLevelQuantizationSlack) {
RTC_DLOG(LS_INFO) << "[agc] Mic volume was manually adjusted. Updating "
"stored level from "
<< level_ << " to " << voe_level;
level_ = voe_level;
// Always allow the user to increase the volume.
if (level_ > max_level_) {
SetMaxLevel(level_);
}
// Take no action in this case, since we can't be sure when the volume
// was manually adjusted. The compressor will still provide some of the
// desired gain change.
agc_->Reset();
return;
}
new_level = std::min(new_level, max_level_);
if (new_level == level_) {
return;
}
stream_analog_level_ = new_level;
RTC_DLOG(LS_INFO) << "[agc] voe_level=" << voe_level << ", level_=" << level_
<< ", new_level=" << new_level;
level_ = new_level;
}
void MonoAgc::SetMaxLevel(int level) {
RTC_DCHECK_GE(level, clipped_level_min_);
max_level_ = level;
// Scale the `kSurplusCompressionGain` linearly across the restricted
// level range.
max_compression_gain_ =
kMaxCompressionGain + std::floor((1.f * kMaxMicLevel - max_level_) /
(kMaxMicLevel - clipped_level_min_) *
kSurplusCompressionGain +
0.5f);
RTC_DLOG(LS_INFO) << "[agc] max_level_=" << max_level_
<< ", max_compression_gain_=" << max_compression_gain_;
}
void MonoAgc::HandleCaptureOutputUsedChange(bool capture_output_used) {
if (capture_output_used_ == capture_output_used) {
return;
}
capture_output_used_ = capture_output_used;
if (capture_output_used) {
// When we start using the output, we should reset things to be safe.
check_volume_on_next_process_ = true;
}
}
int MonoAgc::CheckVolumeAndReset() {
int level = stream_analog_level_;
// Reasons for taking action at startup:
// 1) A person starting a call is expected to be heard.
// 2) Independent of interpretation of `level` == 0 we should raise it so the
// AGC can do its job properly.
if (level == 0 && !startup_) {
RTC_DLOG(LS_INFO)
<< "[agc] VolumeCallbacks returned level=0, taking no action.";
return 0;
}
if (level < 0 || level > kMaxMicLevel) {
RTC_LOG(LS_ERROR) << "[agc] VolumeCallbacks returned an invalid level="
<< level;
return -1;
}
RTC_DLOG(LS_INFO) << "[agc] Initial GetMicVolume()=" << level;
int minLevel = startup_ ? startup_min_level_ : min_mic_level_;
if (level < minLevel) {
level = minLevel;
RTC_DLOG(LS_INFO) << "[agc] Initial volume too low, raising to " << level;
stream_analog_level_ = level;
}
agc_->Reset();
level_ = level;
startup_ = false;
return 0;
}
// Requests the RMS error from AGC and distributes the required gain change
// between the digital compression stage and volume slider. We use the
// compressor first, providing a slack region around the current slider
// position to reduce movement.
//
// If the slider needs to be moved, we check first if the user has adjusted
// it, in which case we take no action and cache the updated level.
void MonoAgc::UpdateGain() {
int rms_error = 0;
if (!agc_->GetRmsErrorDb(&rms_error)) {
// No error update ready.
return;
}
// The compressor will always add at least kMinCompressionGain. In effect,
// this adjusts our target gain upward by the same amount and rms_error
// needs to reflect that.
rms_error += kMinCompressionGain;
// Handle as much error as possible with the compressor first.
int raw_compression =
rtc::SafeClamp(rms_error, kMinCompressionGain, max_compression_gain_);
// Deemphasize the compression gain error. Move halfway between the current
// target and the newly received target. This serves to soften perceptible
// intra-talkspurt adjustments, at the cost of some adaptation speed.
if ((raw_compression == max_compression_gain_ &&
target_compression_ == max_compression_gain_ - 1) ||
(raw_compression == kMinCompressionGain &&
target_compression_ == kMinCompressionGain + 1)) {
// Special case to allow the target to reach the endpoints of the
// compression range. The deemphasis would otherwise halt it at 1 dB shy.
target_compression_ = raw_compression;
} else {
target_compression_ =
(raw_compression - target_compression_) / 2 + target_compression_;
}
// Residual error will be handled by adjusting the volume slider. Use the
// raw rather than deemphasized compression here as we would otherwise
// shrink the amount of slack the compressor provides.
const int residual_gain =
rtc::SafeClamp(rms_error - raw_compression, -kMaxResidualGainChange,
kMaxResidualGainChange);
RTC_DLOG(LS_INFO) << "[agc] rms_error=" << rms_error
<< ", target_compression=" << target_compression_
<< ", residual_gain=" << residual_gain;
if (residual_gain == 0)
return;
int old_level = level_;
SetLevel(LevelFromGainError(residual_gain, level_, min_mic_level_));
if (old_level != level_) {
// level_ was updated by SetLevel; log the new value.
RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.AgcSetLevel", level_, 1,
kMaxMicLevel, 50);
// Reset the AGC since the level has changed.
agc_->Reset();
}
}
void MonoAgc::UpdateCompressor() {
calls_since_last_gain_log_++;
if (calls_since_last_gain_log_ == 100) {
calls_since_last_gain_log_ = 0;
RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc.DigitalGainApplied",
compression_, 0, kMaxCompressionGain,
kMaxCompressionGain + 1);
}
if (compression_ == target_compression_) {
return;
}
// Adapt the compression gain slowly towards the target, in order to avoid
// highly perceptible changes.
if (target_compression_ > compression_) {
compression_accumulator_ += kCompressionGainStep;
} else {
compression_accumulator_ -= kCompressionGainStep;
}
// The compressor accepts integer gains in dB. Adjust the gain when
// we've come within half a stepsize of the nearest integer. (We don't
// check for equality due to potential floating point imprecision).
int new_compression = compression_;
int nearest_neighbor = std::floor(compression_accumulator_ + 0.5);
if (std::fabs(compression_accumulator_ - nearest_neighbor) <
kCompressionGainStep / 2) {
new_compression = nearest_neighbor;
}
// Set the new compression gain.
if (new_compression != compression_) {
RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc.DigitalGainUpdated",
new_compression, 0, kMaxCompressionGain,
kMaxCompressionGain + 1);
compression_ = new_compression;
compression_accumulator_ = new_compression;
new_compression_to_set_ = compression_;
}
}
int AgcManagerDirect::instance_counter_ = 0;
AgcManagerDirect::AgcManagerDirect(
Agc* agc,
int startup_min_level,
int clipped_level_min,
int sample_rate_hz,
int clipped_level_step,
float clipped_ratio_threshold,
int clipped_wait_frames,
const ClippingPredictorConfig& clipping_config)
: AgcManagerDirect(/*num_capture_channels*/ 1,
startup_min_level,
clipped_level_min,
/*disable_digital_adaptive*/ false,
sample_rate_hz,
clipped_level_step,
clipped_ratio_threshold,
clipped_wait_frames,
clipping_config) {
RTC_DCHECK(channel_agcs_[0]);
RTC_DCHECK(agc);
channel_agcs_[0]->set_agc(agc);
}
AgcManagerDirect::AgcManagerDirect(
int num_capture_channels,
int startup_min_level,
int clipped_level_min,
bool disable_digital_adaptive,
int sample_rate_hz,
int clipped_level_step,
float clipped_ratio_threshold,
int clipped_wait_frames,
const ClippingPredictorConfig& clipping_config)
: data_dumper_(
new ApmDataDumper(rtc::AtomicOps::Increment(&instance_counter_))),
use_min_channel_level_(!UseMaxAnalogChannelLevel()),
sample_rate_hz_(sample_rate_hz),
num_capture_channels_(num_capture_channels),
disable_digital_adaptive_(disable_digital_adaptive),
frames_since_clipped_(clipped_wait_frames),
capture_output_used_(true),
clipped_level_step_(clipped_level_step),
clipped_ratio_threshold_(clipped_ratio_threshold),
clipped_wait_frames_(clipped_wait_frames),
channel_agcs_(num_capture_channels),
new_compressions_to_set_(num_capture_channels),
clipping_predictor_(
CreateClippingPredictor(num_capture_channels, clipping_config)),
use_clipping_predictor_step_(!!clipping_predictor_ &&
clipping_config.use_predicted_step),
clipping_predictor_evaluator_(kClippingPredictorEvaluatorHistorySize),
clipping_predictor_log_counter_(0),
clipping_rate_log_(0.0f),
clipping_rate_log_counter_(0) {
const int min_mic_level = GetMinMicLevel();
for (size_t ch = 0; ch < channel_agcs_.size(); ++ch) {
ApmDataDumper* data_dumper_ch = ch == 0 ? data_dumper_.get() : nullptr;
channel_agcs_[ch] = std::make_unique<MonoAgc>(
data_dumper_ch, startup_min_level, clipped_level_min,
disable_digital_adaptive_, min_mic_level);
}
RTC_DCHECK(!channel_agcs_.empty());
RTC_DCHECK_GT(clipped_level_step, 0);
RTC_DCHECK_LE(clipped_level_step, 255);
RTC_DCHECK_GT(clipped_ratio_threshold, 0.f);
RTC_DCHECK_LT(clipped_ratio_threshold, 1.f);
RTC_DCHECK_GT(clipped_wait_frames, 0);
channel_agcs_[0]->ActivateLogging();
}
AgcManagerDirect::~AgcManagerDirect() {}
void AgcManagerDirect::Initialize() {
RTC_DLOG(LS_INFO) << "AgcManagerDirect::Initialize";
data_dumper_->InitiateNewSetOfRecordings();
for (size_t ch = 0; ch < channel_agcs_.size(); ++ch) {
channel_agcs_[ch]->Initialize();
}
capture_output_used_ = true;
AggregateChannelLevels();
clipping_predictor_evaluator_.Reset();
clipping_predictor_log_counter_ = 0;
clipping_rate_log_ = 0.0f;
clipping_rate_log_counter_ = 0;
}
void AgcManagerDirect::SetupDigitalGainControl(
GainControl* gain_control) const {
RTC_DCHECK(gain_control);
if (gain_control->set_mode(GainControl::kFixedDigital) != 0) {
RTC_LOG(LS_ERROR) << "set_mode(GainControl::kFixedDigital) failed.";
}
const int target_level_dbfs = disable_digital_adaptive_ ? 0 : 2;
if (gain_control->set_target_level_dbfs(target_level_dbfs) != 0) {
RTC_LOG(LS_ERROR) << "set_target_level_dbfs() failed.";
}
const int compression_gain_db =
disable_digital_adaptive_ ? 0 : kDefaultCompressionGain;
if (gain_control->set_compression_gain_db(compression_gain_db) != 0) {
RTC_LOG(LS_ERROR) << "set_compression_gain_db() failed.";
}
const bool enable_limiter = !disable_digital_adaptive_;
if (gain_control->enable_limiter(enable_limiter) != 0) {
RTC_LOG(LS_ERROR) << "enable_limiter() failed.";
}
}
void AgcManagerDirect::AnalyzePreProcess(const AudioBuffer* audio) {
RTC_DCHECK(audio);
AnalyzePreProcess(audio->channels_const(), audio->num_frames());
}
void AgcManagerDirect::AnalyzePreProcess(const float* const* audio,
size_t samples_per_channel) {
RTC_DCHECK(audio);
AggregateChannelLevels();
if (!capture_output_used_) {
return;
}
if (!!clipping_predictor_) {
AudioFrameView<const float> frame = AudioFrameView<const float>(
audio, num_capture_channels_, static_cast<int>(samples_per_channel));
clipping_predictor_->Analyze(frame);
}
// Check for clipped samples, as the AGC has difficulty detecting pitch
// under clipping distortion. We do this in the preprocessing phase in order
// to catch clipped echo as well.
//
// If we find a sufficiently clipped frame, drop the current microphone level
// and enforce a new maximum level, dropped the same amount from the current
// maximum. This harsh treatment is an effort to avoid repeated clipped echo
// events. As compensation for this restriction, the maximum compression
// gain is increased, through SetMaxLevel().
float clipped_ratio =
ComputeClippedRatio(audio, num_capture_channels_, samples_per_channel);
clipping_rate_log_ = std::max(clipped_ratio, clipping_rate_log_);
clipping_rate_log_counter_++;
constexpr int kNumFramesIn30Seconds = 3000;
if (clipping_rate_log_counter_ == kNumFramesIn30Seconds) {
LogClippingMetrics(std::round(100.0f * clipping_rate_log_));
clipping_rate_log_ = 0.0f;
clipping_rate_log_counter_ = 0;
}
if (frames_since_clipped_ < clipped_wait_frames_) {
++frames_since_clipped_;
return;
}
const bool clipping_detected = clipped_ratio > clipped_ratio_threshold_;
bool clipping_predicted = false;
int predicted_step = 0;
if (!!clipping_predictor_) {
for (int channel = 0; channel < num_capture_channels_; ++channel) {
const auto step = clipping_predictor_->EstimateClippedLevelStep(
channel, stream_analog_level_, clipped_level_step_,
channel_agcs_[channel]->min_mic_level(), kMaxMicLevel);
if (use_clipping_predictor_step_ && step.has_value()) {
predicted_step = std::max(predicted_step, step.value());
clipping_predicted = true;
}
}
// Clipping prediction evaluation.
absl::optional<int> prediction_interval =
clipping_predictor_evaluator_.Observe(clipping_detected,
clipping_predicted);
if (prediction_interval.has_value()) {
RTC_HISTOGRAM_COUNTS_LINEAR(
"WebRTC.Audio.Agc.ClippingPredictor.PredictionInterval",
prediction_interval.value(), /*min=*/0,
/*max=*/49, /*bucket_count=*/50);
}
clipping_predictor_log_counter_++;
if (clipping_predictor_log_counter_ == kNumFramesIn30Seconds) {
LogClippingPredictorMetrics(clipping_predictor_evaluator_);
clipping_predictor_log_counter_ = 0;
}
}
if (clipping_detected || clipping_predicted) {
int step = clipped_level_step_;
if (clipping_detected) {
RTC_DLOG(LS_INFO) << "[agc] Clipping detected. clipped_ratio="
<< clipped_ratio;
}
if (clipping_predicted) {
step = std::max(predicted_step, clipped_level_step_);
RTC_DLOG(LS_INFO) << "[agc] Clipping predicted. step=" << step;
}
for (auto& state_ch : channel_agcs_) {
state_ch->HandleClipping(step);
}
frames_since_clipped_ = 0;
if (!!clipping_predictor_) {
clipping_predictor_->Reset();
clipping_predictor_evaluator_.Reset();
}
}
AggregateChannelLevels();
}
void AgcManagerDirect::Process(const AudioBuffer* audio) {
AggregateChannelLevels();
if (!capture_output_used_) {
return;
}
for (size_t ch = 0; ch < channel_agcs_.size(); ++ch) {
int16_t* audio_use = nullptr;
std::array<int16_t, AudioBuffer::kMaxSampleRate / 100> audio_data;
int num_frames_per_band;
if (audio) {
FloatS16ToS16(audio->split_bands_const_f(ch)[0],
audio->num_frames_per_band(), audio_data.data());
audio_use = audio_data.data();
num_frames_per_band = audio->num_frames_per_band();
} else {
// Only used for testing.
// TODO(peah): Change unittests to only allow on non-null audio input.
num_frames_per_band = 320;
}
channel_agcs_[ch]->Process(audio_use, num_frames_per_band, sample_rate_hz_);
new_compressions_to_set_[ch] = channel_agcs_[ch]->new_compression();
}
AggregateChannelLevels();
}
absl::optional<int> AgcManagerDirect::GetDigitalComressionGain() {
return new_compressions_to_set_[channel_controlling_gain_];
}
void AgcManagerDirect::HandleCaptureOutputUsedChange(bool capture_output_used) {
for (size_t ch = 0; ch < channel_agcs_.size(); ++ch) {
channel_agcs_[ch]->HandleCaptureOutputUsedChange(capture_output_used);
}
capture_output_used_ = capture_output_used;
}
float AgcManagerDirect::voice_probability() const {
float max_prob = 0.f;
for (const auto& state_ch : channel_agcs_) {
max_prob = std::max(max_prob, state_ch->voice_probability());
}
return max_prob;
}
void AgcManagerDirect::set_stream_analog_level(int level) {
for (size_t ch = 0; ch < channel_agcs_.size(); ++ch) {
channel_agcs_[ch]->set_stream_analog_level(level);
}
AggregateChannelLevels();
}
void AgcManagerDirect::AggregateChannelLevels() {
stream_analog_level_ = channel_agcs_[0]->stream_analog_level();
channel_controlling_gain_ = 0;
if (use_min_channel_level_) {
for (size_t ch = 1; ch < channel_agcs_.size(); ++ch) {
int level = channel_agcs_[ch]->stream_analog_level();
if (level < stream_analog_level_) {
stream_analog_level_ = level;
channel_controlling_gain_ = static_cast<int>(ch);
}
}
} else {
for (size_t ch = 1; ch < channel_agcs_.size(); ++ch) {
int level = channel_agcs_[ch]->stream_analog_level();
if (level > stream_analog_level_) {
stream_analog_level_ = level;
channel_controlling_gain_ = static_cast<int>(ch);
}
}
}
}
} // namespace webrtc