blob: d4e32f56abf2a2b42bea9dd4686fa0267513d39b [file] [log] [blame]
/*
* Copyright (c) 2018 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/aec3/stationarity_estimator.h"
#include <algorithm>
#include <array>
#include <vector>
#include "modules/audio_processing/aec3/aec3_common.h"
#include "modules/audio_processing/aec3/vector_buffer.h"
#include "modules/audio_processing/logging/apm_data_dumper.h"
#include "rtc_base/atomicops.h"
namespace webrtc {
namespace {
constexpr float kMinNoisePower = 10.f;
constexpr int kHangoverBlocks = kNumBlocksPerSecond / 20;
constexpr int kNBlocksAverageInitPhase = 20;
constexpr int kNBlocksInitialPhase = kNumBlocksPerSecond * 2.;
} // namespace
StationarityEstimator::StationarityEstimator()
: data_dumper_(
new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))) {
Reset();
}
StationarityEstimator::~StationarityEstimator() = default;
void StationarityEstimator::Reset() {
noise_.Reset();
hangovers_.fill(0);
stationarity_flags_.fill(false);
render_reverb_.Reset();
}
// Update just the noise estimator. Usefull until the delay is known
void StationarityEstimator::UpdateNoiseEstimator(
rtc::ArrayView<const float> spectrum) {
noise_.Update(spectrum);
data_dumper_->DumpRaw("aec3_stationarity_noise_spectrum", noise_.Spectrum());
}
void StationarityEstimator::UpdateStationarityFlags(
const VectorBuffer& spectrum_buffer,
int idx_current,
int num_lookahead,
float reverb_decay) {
std::array<int, kWindowLength> indexes;
int num_lookahead_bounded = std::min(num_lookahead, kWindowLength - 1);
int idx = idx_current;
if (num_lookahead_bounded < kWindowLength - 1) {
int num_lookback = (kWindowLength - 1) - num_lookahead_bounded;
idx = spectrum_buffer.OffsetIndex(idx_current, num_lookback);
}
// For estimating the stationarity properties of the current frame, the
// power for each band is accumulated for several consecutive spectra in the
// method EstimateBandStationarity.
// In order to avoid getting the indexes of the spectra for every band with
// its associated overhead, those indexes are stored in an array and then use
// when the estimation is done.
indexes[0] = idx;
for (size_t k = 1; k < indexes.size(); ++k) {
indexes[k] = spectrum_buffer.DecIndex(indexes[k - 1]);
}
RTC_DCHECK_EQ(
spectrum_buffer.DecIndex(indexes[kWindowLength - 1]),
spectrum_buffer.OffsetIndex(idx_current, -(num_lookahead_bounded + 1)));
int idx_past = spectrum_buffer.IncIndex(idx_current);
render_reverb_.UpdateReverbContributions(spectrum_buffer.buffer[idx_past], 1.,
reverb_decay);
for (size_t k = 0; k < stationarity_flags_.size(); ++k) {
stationarity_flags_[k] = EstimateBandStationarity(
spectrum_buffer, render_reverb_.GetPowerSpectrum(), indexes, k);
}
UpdateHangover();
SmoothStationaryPerFreq();
}
bool StationarityEstimator::EstimateBandStationarity(
const VectorBuffer& spectrum_buffer,
const std::array<float, kFftLengthBy2Plus1>& reverb,
const std::array<int, kWindowLength>& indexes,
size_t band) const {
constexpr float kThrStationarity = 10.f;
float acum_power = 0.f;
for (auto idx : indexes) {
acum_power += spectrum_buffer.buffer[idx][band];
}
acum_power += reverb[band];
float noise = kWindowLength * GetStationarityPowerBand(band);
RTC_CHECK_LT(0.f, noise);
bool stationary = acum_power < kThrStationarity * noise;
data_dumper_->DumpRaw("aec3_stationarity_long_ratio", acum_power / noise);
return stationary;
}
bool StationarityEstimator::AreAllBandsStationary() {
for (auto b : stationarity_flags_) {
if (!b)
return false;
}
return true;
}
void StationarityEstimator::UpdateHangover() {
bool reduce_hangover = AreAllBandsStationary();
for (size_t k = 0; k < stationarity_flags_.size(); ++k) {
if (!stationarity_flags_[k]) {
hangovers_[k] = kHangoverBlocks;
} else if (reduce_hangover) {
hangovers_[k] = std::max(hangovers_[k] - 1, 0);
}
}
}
void StationarityEstimator::SmoothStationaryPerFreq() {
std::array<bool, kFftLengthBy2Plus1> all_ahead_stationary_smooth;
for (size_t k = 1; k < kFftLengthBy2Plus1 - 1; ++k) {
all_ahead_stationary_smooth[k] = stationarity_flags_[k - 1] &&
stationarity_flags_[k] &&
stationarity_flags_[k + 1];
}
all_ahead_stationary_smooth[0] = all_ahead_stationary_smooth[1];
all_ahead_stationary_smooth[kFftLengthBy2Plus1 - 1] =
all_ahead_stationary_smooth[kFftLengthBy2Plus1 - 2];
stationarity_flags_ = all_ahead_stationary_smooth;
}
int StationarityEstimator::instance_count_ = 0;
StationarityEstimator::NoiseSpectrum::NoiseSpectrum() {
Reset();
}
StationarityEstimator::NoiseSpectrum::~NoiseSpectrum() = default;
void StationarityEstimator::NoiseSpectrum::Reset() {
block_counter_ = 0;
noise_spectrum_.fill(kMinNoisePower);
}
void StationarityEstimator::NoiseSpectrum::Update(
rtc::ArrayView<const float> spectrum) {
RTC_DCHECK_EQ(kFftLengthBy2Plus1, spectrum.size());
++block_counter_;
float alpha = GetAlpha();
for (size_t k = 0; k < spectrum.size(); ++k) {
if (block_counter_ <= kNBlocksAverageInitPhase) {
noise_spectrum_[k] += (1.f / kNBlocksAverageInitPhase) * spectrum[k];
} else {
noise_spectrum_[k] =
UpdateBandBySmoothing(spectrum[k], noise_spectrum_[k], alpha);
}
}
}
float StationarityEstimator::NoiseSpectrum::GetAlpha() const {
constexpr float kAlpha = 0.004f;
constexpr float kAlphaInit = 0.04f;
constexpr float kTiltAlpha = (kAlphaInit - kAlpha) / kNBlocksInitialPhase;
if (block_counter_ > (kNBlocksInitialPhase + kNBlocksAverageInitPhase)) {
return kAlpha;
} else {
return kAlphaInit -
kTiltAlpha * (block_counter_ - kNBlocksAverageInitPhase);
}
}
float StationarityEstimator::NoiseSpectrum::UpdateBandBySmoothing(
float power_band,
float power_band_noise,
float alpha) const {
float power_band_noise_updated = power_band_noise;
if (power_band_noise < power_band) {
RTC_DCHECK_GT(power_band, 0.f);
float alpha_inc = alpha * (power_band_noise / power_band);
if (block_counter_ > kNBlocksInitialPhase) {
if (10.f * power_band_noise < power_band) {
alpha_inc *= 0.1f;
}
}
power_band_noise_updated += alpha_inc * (power_band - power_band_noise);
} else {
power_band_noise_updated += alpha * (power_band - power_band_noise);
power_band_noise_updated =
std::max(power_band_noise_updated, kMinNoisePower);
}
return power_band_noise_updated;
}
} // namespace webrtc