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

Make the nonlinear beamformer steerable

Browse Source 
Depends on this CL: https://codereview.webrtc.org/1395453004/

R=andrew@webrtc.org

Review URL: https://codereview.webrtc.org/1394103003 .

Cr-Commit-Position: refs/heads/master@{#10458}
This commit is contained in:
Alejandro Luebs
2015-10-29 18:21:34 -07:00
parent 7367463acc
commit cb3f9bd9c0
12 changed files with 613 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/modules/audio_processing/audio_processing_impl.cc
View File

@ -225,6 +225,7 @@ AudioProcessingImpl::AudioProcessingImpl(const Config& config,
beamformer_enabled_(config.Get<Beamforming>().enabled),
beamformer_(beamformer),
array_geometry_(config.Get<Beamforming>().array_geometry),
target_direction_(config.Get<Beamforming>().target_direction),
intelligibility_enabled_(config.Get<Intelligibility>().enabled) {
echo_cancellation_ = new EchoCancellationImpl(this, crit_);
component_list_.push_back(echo_cancellation_);
@ -1099,7 +1100,8 @@ void AudioProcessingImpl::InitializeTransient() {
void AudioProcessingImpl::InitializeBeamformer() {
if (beamformer_enabled_) {
if (!beamformer_) {
beamformer_.reset(new NonlinearBeamformer(array_geometry_));
beamformer_.reset(
new NonlinearBeamformer(array_geometry_, target_direction_));
}
beamformer_->Initialize(kChunkSizeMs, split_rate_);
}

1
webrtc/modules/audio_processing/audio_processing_impl.h
View File

@ -208,6 +208,7 @@ class AudioProcessingImpl : public AudioProcessing {
const bool beamformer_enabled_;
rtc::scoped_ptr<Beamformer<float>> beamformer_;
const std::vector<Point> array_geometry_;
const SphericalPointf target_direction_;
bool intelligibility_enabled_;
rtc::scoped_ptr<IntelligibilityEnhancer> intelligibility_enhancer_;

86
webrtc/modules/audio_processing/beamformer/array_util.cc
View File

@ -16,6 +16,11 @@
#include "webrtc/base/checks.h"
namespace webrtc {
namespace {
const float kMaxDotProduct = 1e-6f;
} // namespace
float GetMinimumSpacing(const std::vector<Point>& array_geometry) {
RTC_CHECK_GT(array_geometry.size(), 1u);
@ -29,4 +34,85 @@ float GetMinimumSpacing(const std::vector<Point>& array_geometry) {
return mic_spacing;
}
Point PairDirection(const Point& a, const Point& b) {
return {b.x() - a.x(), b.y() - a.y(), b.z() - a.z()};
}
float DotProduct(const Point& a, const Point& b) {
return a.x() * b.x() + a.y() * b.y() + a.z() * b.z();
}
Point CrossProduct(const Point& a, const Point& b) {
return {a.y() * b.z() - a.z() * b.y(), a.z() * b.x() - a.x() * b.z(),
a.x() * b.y() - a.y() * b.x()};
}
bool AreParallel(const Point& a, const Point& b) {
Point cross_product = CrossProduct(a, b);
return DotProduct(cross_product, cross_product) < kMaxDotProduct;
}
bool ArePerpendicular(const Point& a, const Point& b) {
return std::abs(DotProduct(a, b)) < kMaxDotProduct;
}
rtc::Maybe<Point> GetDirectionIfLinear(
const std::vector<Point>& array_geometry) {
RTC_DCHECK_GT(array_geometry.size(), 1u);
const Point first_pair_direction =
PairDirection(array_geometry[0], array_geometry[1]);
for (size_t i = 2u; i < array_geometry.size(); ++i) {
const Point pair_direction =
PairDirection(array_geometry[i - 1], array_geometry[i]);
if (!AreParallel(first_pair_direction, pair_direction)) {
return rtc::Maybe<Point>();
}
}
return first_pair_direction;
}
rtc::Maybe<Point> GetNormalIfPlanar(const std::vector<Point>& array_geometry) {
RTC_DCHECK_GT(array_geometry.size(), 1u);
const Point first_pair_direction =
PairDirection(array_geometry[0], array_geometry[1]);
Point pair_direction(0.f, 0.f, 0.f);
size_t i = 2u;
bool is_linear = true;
for (; i < array_geometry.size() && is_linear; ++i) {
pair_direction = PairDirection(array_geometry[i - 1], array_geometry[i]);
if (!AreParallel(first_pair_direction, pair_direction)) {
is_linear = false;
}
}
if (is_linear) {
return rtc::Maybe<Point>();
}
const Point normal_direction =
CrossProduct(first_pair_direction, pair_direction);
for (; i < array_geometry.size(); ++i) {
pair_direction = PairDirection(array_geometry[i - 1], array_geometry[i]);
if (!ArePerpendicular(normal_direction, pair_direction)) {
return rtc::Maybe<Point>();
}
}
return normal_direction;
}
rtc::Maybe<Point> GetArrayNormalIfExists(
const std::vector<Point>& array_geometry) {
const rtc::Maybe<Point> direction = GetDirectionIfLinear(array_geometry);
if (direction) {
return Point(direction->y(), -direction->x(), 0.f);
}
const rtc::Maybe<Point> normal = GetNormalIfPlanar(array_geometry);
if (normal && normal->z() < kMaxDotProduct) {
return normal;
}
return rtc::Maybe<Point>();
}
Point AzimuthToPoint(float azimuth) {
return Point(std::cos(azimuth), std::sin(azimuth), 0.f);
}
} // namespace webrtc

55
webrtc/modules/audio_processing/beamformer/array_util.h
View File

@ -14,11 +14,23 @@
#include <cmath>
#include <vector>
#include "webrtc/base/maybe.h"
namespace webrtc {
// Coordinates in meters.
// Coordinates in meters. The convention used is:
// x: the horizontal dimension, with positive to the right from the camera's
// perspective.
// y: the depth dimension, with positive forward from the camera's
// perspective.
// z: the vertical dimension, with positive upwards.
template<typename T>
struct CartesianPoint {
CartesianPoint() {
c[0] = 0;
c[1] = 0;
c[2] = 0;
}
CartesianPoint(T x, T y, T z) {
c[0] = x;
c[1] = y;
@ -32,10 +44,35 @@ struct CartesianPoint {
using Point = CartesianPoint<float>;
// Calculates the direction from a to b.
Point PairDirection(const Point& a, const Point& b);
float DotProduct(const Point& a, const Point& b);
Point CrossProduct(const Point& a, const Point& b);
bool AreParallel(const Point& a, const Point& b);
bool ArePerpendicular(const Point& a, const Point& b);
// Returns the minimum distance between any two Points in the given
// |array_geometry|.
float GetMinimumSpacing(const std::vector<Point>& array_geometry);
// If the given array geometry is linear it returns the direction without
// normalizing.
rtc::Maybe<Point> GetDirectionIfLinear(
const std::vector<Point>& array_geometry);
// If the given array geometry is planar it returns the normal without
// normalizing.
rtc::Maybe<Point> GetNormalIfPlanar(const std::vector<Point>& array_geometry);
// Returns the normal of an array if it has one and it is in the xy-plane.
rtc::Maybe<Point> GetArrayNormalIfExists(
const std::vector<Point>& array_geometry);
// The resulting Point will be in the xy-plane.
Point AzimuthToPoint(float azimuth);
template<typename T>
float Distance(CartesianPoint<T> a, CartesianPoint<T> b) {
return std::sqrt((a.x() - b.x()) * (a.x() - b.x()) +
@ -43,6 +80,11 @@ float Distance(CartesianPoint<T> a, CartesianPoint<T> b) {
(a.z() - b.z()) * (a.z() - b.z()));
}
// The convention used:
// azimuth: zero is to the right from the camera's perspective, with positive
// angles in radians counter-clockwise.
// elevation: zero is horizontal, with positive angles in radians upwards.
// radius: distance from the camera in meters.
template <typename T>
struct SphericalPoint {
SphericalPoint(T azimuth, T elevation, T radius) {
@ -58,6 +100,17 @@ struct SphericalPoint {
using SphericalPointf = SphericalPoint<float>;
// Helper functions to transform degrees to radians and the inverse.
template <typename T>
T DegreesToRadians(T angle_degrees) {
return M_PI * angle_degrees / 180;
}
template <typename T>
T RadiansToDegrees(T angle_radians) {
return 180 * angle_radians / M_PI;
}
} // namespace webrtc
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_BEAMFORMER_ARRAY_UTIL_H_

173
webrtc/modules/audio_processing/beamformer/array_util_unittest.cc
View File

@ -8,25 +8,178 @@
* be found in the AUTHORS file in the root of the source tree.
*/
// MSVC++ requires this to be set before any other includes to get M_PI.
#define _USE_MATH_DEFINES
#include "webrtc/modules/audio_processing/beamformer/array_util.h"
#include <math.h>
#include <vector>
#include "testing/gtest/include/gtest/gtest.h"
namespace webrtc {
bool operator==(const Point& lhs, const Point& rhs) {
return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z();
}
TEST(ArrayUtilTest, PairDirection) {
EXPECT_EQ(Point(1.f, 2.f, 3.f),
PairDirection(Point(0.f, 0.f, 0.f), Point(1.f, 2.f, 3.f)));
EXPECT_EQ(Point(-1.f, -2.f, -3.f),
PairDirection(Point(1.f, 2.f, 3.f), Point(0.f, 0.f, 0.f)));
EXPECT_EQ(Point(0.f, 0.f, 0.f),
PairDirection(Point(1.f, 0.f, 0.f), Point(1.f, 0.f, 0.f)));
EXPECT_EQ(Point(-1.f, 2.f, 0.f),
PairDirection(Point(1.f, 0.f, 0.f), Point(0.f, 2.f, 0.f)));
EXPECT_EQ(Point(-4.f, 4.f, -4.f),
PairDirection(Point(1.f, -2.f, 3.f), Point(-3.f, 2.f, -1.f)));
}
TEST(ArrayUtilTest, DotProduct) {
EXPECT_FLOAT_EQ(0.f, DotProduct(Point(0.f, 0.f, 0.f), Point(1.f, 2.f, 3.f)));
EXPECT_FLOAT_EQ(0.f, DotProduct(Point(1.f, 0.f, 2.f), Point(0.f, 3.f, 0.f)));
EXPECT_FLOAT_EQ(0.f, DotProduct(Point(1.f, 1.f, 0.f), Point(1.f, -1.f, 0.f)));
EXPECT_FLOAT_EQ(2.f, DotProduct(Point(1.f, 0.f, 0.f), Point(2.f, 0.f, 0.f)));
EXPECT_FLOAT_EQ(-6.f,
DotProduct(Point(-2.f, 0.f, 0.f), Point(3.f, 0.f, 0.f)));
EXPECT_FLOAT_EQ(-10.f,
DotProduct(Point(1.f, -2.f, 3.f), Point(-3.f, 2.f, -1.f)));
}
TEST(ArrayUtilTest, CrossProduct) {
EXPECT_EQ(Point(0.f, 0.f, 0.f),
CrossProduct(Point(0.f, 0.f, 0.f), Point(1.f, 2.f, 3.f)));
EXPECT_EQ(Point(0.f, 0.f, 1.f),
CrossProduct(Point(1.f, 0.f, 0.f), Point(0.f, 1.f, 0.f)));
EXPECT_EQ(Point(1.f, 0.f, 0.f),
CrossProduct(Point(0.f, 1.f, 0.f), Point(0.f, 0.f, 1.f)));
EXPECT_EQ(Point(0.f, -1.f, 0.f),
CrossProduct(Point(1.f, 0.f, 0.f), Point(0.f, 0.f, 1.f)));
EXPECT_EQ(Point(-4.f, -8.f, -4.f),
CrossProduct(Point(1.f, -2.f, 3.f), Point(-3.f, 2.f, -1.f)));
}
TEST(ArrayUtilTest, AreParallel) {
EXPECT_TRUE(AreParallel(Point(0.f, 0.f, 0.f), Point(1.f, 2.f, 3.f)));
EXPECT_FALSE(AreParallel(Point(1.f, 0.f, 2.f), Point(0.f, 3.f, 0.f)));
EXPECT_FALSE(AreParallel(Point(1.f, 2.f, 0.f), Point(1.f, -0.5f, 0.f)));
EXPECT_FALSE(AreParallel(Point(1.f, -2.f, 3.f), Point(-3.f, 2.f, -1.f)));
EXPECT_TRUE(AreParallel(Point(1.f, 0.f, 0.f), Point(2.f, 0.f, 0.f)));
EXPECT_TRUE(AreParallel(Point(1.f, 2.f, 3.f), Point(-2.f, -4.f, -6.f)));
}
TEST(ArrayUtilTest, ArePerpendicular) {
EXPECT_TRUE(ArePerpendicular(Point(0.f, 0.f, 0.f), Point(1.f, 2.f, 3.f)));
EXPECT_TRUE(ArePerpendicular(Point(1.f, 0.f, 2.f), Point(0.f, 3.f, 0.f)));
EXPECT_TRUE(ArePerpendicular(Point(1.f, 2.f, 0.f), Point(1.f, -0.5f, 0.f)));
EXPECT_FALSE(ArePerpendicular(Point(1.f, -2.f, 3.f), Point(-3.f, 2.f, -1.f)));
EXPECT_FALSE(ArePerpendicular(Point(1.f, 0.f, 0.f), Point(2.f, 0.f, 0.f)));
EXPECT_FALSE(ArePerpendicular(Point(1.f, 2.f, 3.f), Point(-2.f, -4.f, -6.f)));
}
TEST(ArrayUtilTest, GetMinimumSpacing) {
std::vector<Point> array_geometry;
array_geometry.push_back(Point(0.f, 0.f, 0.f));
array_geometry.push_back(Point(0.1f, 0.f, 0.f));
EXPECT_FLOAT_EQ(0.1f, GetMinimumSpacing(array_geometry));
array_geometry.push_back(Point(0.f, 0.05f, 0.f));
EXPECT_FLOAT_EQ(0.05f, GetMinimumSpacing(array_geometry));
array_geometry.push_back(Point(0.f, 0.f, 0.02f));
EXPECT_FLOAT_EQ(0.02f, GetMinimumSpacing(array_geometry));
array_geometry.push_back(Point(-0.003f, -0.004f, 0.02f));
EXPECT_FLOAT_EQ(0.005f, GetMinimumSpacing(array_geometry));
std::vector<Point> geometry;
geometry.push_back(Point(0.f, 0.f, 0.f));
geometry.push_back(Point(0.1f, 0.f, 0.f));
EXPECT_FLOAT_EQ(0.1f, GetMinimumSpacing(geometry));
geometry.push_back(Point(0.f, 0.05f, 0.f));
EXPECT_FLOAT_EQ(0.05f, GetMinimumSpacing(geometry));
geometry.push_back(Point(0.f, 0.f, 0.02f));
EXPECT_FLOAT_EQ(0.02f, GetMinimumSpacing(geometry));
geometry.push_back(Point(-0.003f, -0.004f, 0.02f));
EXPECT_FLOAT_EQ(0.005f, GetMinimumSpacing(geometry));
}
TEST(ArrayUtilTest, GetDirectionIfLinear) {
std::vector<Point> geometry;
geometry.push_back(Point(0.f, 0.f, 0.f));
geometry.push_back(Point(0.1f, 0.f, 0.f));
EXPECT_TRUE(
AreParallel(Point(1.f, 0.f, 0.f), *GetDirectionIfLinear(geometry)));
geometry.push_back(Point(0.15f, 0.f, 0.f));
EXPECT_TRUE(
AreParallel(Point(1.f, 0.f, 0.f), *GetDirectionIfLinear(geometry)));
geometry.push_back(Point(-0.2f, 0.f, 0.f));
EXPECT_TRUE(
AreParallel(Point(1.f, 0.f, 0.f), *GetDirectionIfLinear(geometry)));
geometry.push_back(Point(0.05f, 0.f, 0.f));
EXPECT_TRUE(
AreParallel(Point(1.f, 0.f, 0.f), *GetDirectionIfLinear(geometry)));
geometry.push_back(Point(0.1f, 0.1f, 0.f));
EXPECT_FALSE(GetDirectionIfLinear(geometry));
geometry.push_back(Point(0.f, 0.f, -0.2f));
EXPECT_FALSE(GetDirectionIfLinear(geometry));
}
TEST(ArrayUtilTest, GetNormalIfPlanar) {
std::vector<Point> geometry;
geometry.push_back(Point(0.f, 0.f, 0.f));
geometry.push_back(Point(0.1f, 0.f, 0.f));
EXPECT_FALSE(GetNormalIfPlanar(geometry));
geometry.push_back(Point(0.15f, 0.f, 0.f));
EXPECT_FALSE(GetNormalIfPlanar(geometry));
geometry.push_back(Point(0.1f, 0.2f, 0.f));
EXPECT_TRUE(AreParallel(Point(0.f, 0.f, 1.f), *GetNormalIfPlanar(geometry)));
geometry.push_back(Point(0.f, -0.15f, 0.f));
EXPECT_TRUE(AreParallel(Point(0.f, 0.f, 1.f), *GetNormalIfPlanar(geometry)));
geometry.push_back(Point(0.f, 0.1f, 0.2f));
EXPECT_FALSE(GetNormalIfPlanar(geometry));
geometry.push_back(Point(0.f, 0.f, -0.15f));
EXPECT_FALSE(GetNormalIfPlanar(geometry));
geometry.push_back(Point(0.1f, 0.2f, 0.f));
EXPECT_FALSE(GetNormalIfPlanar(geometry));
}
TEST(ArrayUtilTest, GetArrayNormalIfExists) {
std::vector<Point> geometry;
geometry.push_back(Point(0.f, 0.f, 0.f));
geometry.push_back(Point(0.1f, 0.f, 0.f));
EXPECT_TRUE(
AreParallel(Point(0.f, 1.f, 0.f), *GetArrayNormalIfExists(geometry)));
geometry.push_back(Point(0.15f, 0.f, 0.f));
EXPECT_TRUE(
AreParallel(Point(0.f, 1.f, 0.f), *GetArrayNormalIfExists(geometry)));
geometry.push_back(Point(0.1f, 0.f, 0.2f));
EXPECT_TRUE(
AreParallel(Point(0.f, 1.f, 0.f), *GetArrayNormalIfExists(geometry)));
geometry.push_back(Point(0.f, 0.f, -0.1f));
EXPECT_TRUE(
AreParallel(Point(0.f, 1.f, 0.f), *GetArrayNormalIfExists(geometry)));
geometry.push_back(Point(0.1f, 0.2f, 0.3f));
EXPECT_FALSE(GetArrayNormalIfExists(geometry));
geometry.push_back(Point(0.f, -0.1f, 0.f));
EXPECT_FALSE(GetArrayNormalIfExists(geometry));
geometry.push_back(Point(1.f, 0.f, -0.2f));
EXPECT_FALSE(GetArrayNormalIfExists(geometry));
}
TEST(ArrayUtilTest, DegreesToRadians) {
EXPECT_FLOAT_EQ(0.f, DegreesToRadians(0.f));
EXPECT_FLOAT_EQ(static_cast<float>(M_PI) / 6.f, DegreesToRadians(30.f));
EXPECT_FLOAT_EQ(-static_cast<float>(M_PI) / 4.f, DegreesToRadians(-45.f));
EXPECT_FLOAT_EQ(static_cast<float>(M_PI) / 3.f, DegreesToRadians(60.f));
EXPECT_FLOAT_EQ(-static_cast<float>(M_PI) / 2.f, DegreesToRadians(-90.f));
EXPECT_FLOAT_EQ(2.f * static_cast<float>(M_PI) / 3.f,
DegreesToRadians(120.f));
EXPECT_FLOAT_EQ(-3.f * static_cast<float>(M_PI) / 4.f,
DegreesToRadians(-135.f));
EXPECT_FLOAT_EQ(5.f * static_cast<float>(M_PI) / 6.f,
DegreesToRadians(150.f));
EXPECT_FLOAT_EQ(-static_cast<float>(M_PI), DegreesToRadians(-180.f));
}
TEST(ArrayUtilTest, RadiansToDegrees) {
EXPECT_FLOAT_EQ(0.f, RadiansToDegrees(0.f));
EXPECT_FLOAT_EQ(30.f, RadiansToDegrees(M_PI / 6.f));
EXPECT_FLOAT_EQ(-45.f, RadiansToDegrees(-M_PI / 4.f));
EXPECT_FLOAT_EQ(60.f, RadiansToDegrees(M_PI / 3.f));
EXPECT_FLOAT_EQ(-90.f, RadiansToDegrees(-M_PI / 2.f));
EXPECT_FLOAT_EQ(120.f, RadiansToDegrees(2.f * M_PI / 3.f));
EXPECT_FLOAT_EQ(-135.f, RadiansToDegrees(-3.f * M_PI / 4.f));
EXPECT_FLOAT_EQ(150.f, RadiansToDegrees(5.f * M_PI / 6.f));
EXPECT_FLOAT_EQ(-180.f, RadiansToDegrees(-M_PI));
}
} // namespace webrtc

3
webrtc/modules/audio_processing/beamformer/beamformer.h
View File

@ -32,6 +32,9 @@ class Beamformer {
// Needs to be called before the the Beamformer can be used.
virtual void Initialize(int chunk_size_ms, int sample_rate_hz) = 0;
// Aim the beamformer at a point in space.
virtual void AimAt(const SphericalPointf& spherical_point) = 0;
// Indicates whether a given point is inside of the beam.
virtual bool IsInBeam(const SphericalPointf& spherical_point) { return true; }

184
webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.cc
View File

@ -29,13 +29,6 @@ const float kKbdAlpha = 1.5f;
const float kSpeedOfSoundMeterSeconds = 343;
// For both target and interference angles, PI / 2 is perpendicular to the
// microphone array, facing forwards. The positive direction goes
// counterclockwise.
// The angle at which we amplify sound.
// TODO(aluebs): Make the target angle dynamically settable.
const float kTargetAngleRadians = static_cast<float>(M_PI) / 2.f;
// The minimum separation in radians between the target direction and an
// interferer scenario.
const float kMinAwayRadians = 0.2f;
@ -50,8 +43,6 @@ const float kAwaySlope = 0.008f;
// Rpsi = Rpsi_angled * kBalance + Rpsi_uniform * (1 - kBalance)
const float kBalance = 0.95f;
const float kHalfBeamWidthRadians = static_cast<float>(M_PI) * 20.f / 180.f;
// Alpha coefficients for mask smoothing.
const float kMaskTimeSmoothAlpha = 0.2f;
const float kMaskFrequencySmoothAlpha = 0.6f;
@ -187,14 +178,23 @@ std::vector<Point> GetCenteredArray(std::vector<Point> array_geometry) {
} // namespace
const float NonlinearBeamformer::kHalfBeamWidthRadians = DegreesToRadians(20.f);
// static
const size_t NonlinearBeamformer::kNumFreqBins;
NonlinearBeamformer::NonlinearBeamformer(
const std::vector<Point>& array_geometry)
const std::vector<Point>& array_geometry,
SphericalPointf target_direction)
: num_input_channels_(array_geometry.size()),
array_geometry_(GetCenteredArray(array_geometry)),
min_mic_spacing_(GetMinimumSpacing(array_geometry)) {
array_normal_(GetArrayNormalIfExists(array_geometry)),
min_mic_spacing_(GetMinimumSpacing(array_geometry)),
target_angle_radians_(target_direction.azimuth()),
away_radians_(std::min(
static_cast<float>(M_PI),
std::max(kMinAwayRadians,
kAwaySlope * static_cast<float>(M_PI) / min_mic_spacing_))) {
WindowGenerator::KaiserBesselDerived(kKbdAlpha, kFftSize, window_);
}
@ -202,7 +202,6 @@ void NonlinearBeamformer::Initialize(int chunk_size_ms, int sample_rate_hz) {
chunk_length_ =
static_cast<size_t>(sample_rate_hz / (1000.f / chunk_size_ms));
sample_rate_hz_ = sample_rate_hz;
InitFrequencyCorrectionRanges();
high_pass_postfilter_mask_ = 1.f;
is_target_present_ = false;
@ -223,36 +222,13 @@ void NonlinearBeamformer::Initialize(int chunk_size_ms, int sample_rate_hz) {
wave_numbers_[i] = 2 * M_PI * freq_hz / kSpeedOfSoundMeterSeconds;
}
// Initialize all nonadaptive values before looping through the frames.
InitInterfAngles();
InitDelaySumMasks();
InitTargetCovMats();
InitInterfCovMats();
for (size_t i = 0; i < kNumFreqBins; ++i) {
rxiws_[i] = Norm(target_cov_mats_[i], delay_sum_masks_[i]);
rpsiws_[i].clear();
for (size_t j = 0; j < interf_angles_radians_.size(); ++j) {
rpsiws_[i].push_back(Norm(*interf_cov_mats_[i][j], delay_sum_masks_[i]));
}
}
InitLowFrequencyCorrectionRanges();
InitDiffuseCovMats();
AimAt(SphericalPointf(target_angle_radians_, 0.f, 1.f));
}
void NonlinearBeamformer::InitFrequencyCorrectionRanges() {
const float kAliasingFreqHz =
kSpeedOfSoundMeterSeconds /
(min_mic_spacing_ * (1.f + std::abs(std::cos(kTargetAngleRadians))));
const float kHighMeanStartHz = std::min(0.5f * kAliasingFreqHz,
sample_rate_hz_ / 2.f);
const float kHighMeanEndHz = std::min(0.75f * kAliasingFreqHz,
sample_rate_hz_ / 2.f);
low_mean_start_bin_ = Round(kLowMeanStartHz * kFftSize / sample_rate_hz_);
low_mean_end_bin_ = Round(kLowMeanEndHz * kFftSize / sample_rate_hz_);
high_mean_start_bin_ = Round(kHighMeanStartHz * kFftSize / sample_rate_hz_);
high_mean_end_bin_ = Round(kHighMeanEndHz * kFftSize / sample_rate_hz_);
// These bin indexes determine the regions over which a mean is taken. This
// is applied as a constant value over the adjacent end "frequency correction"
// These bin indexes determine the regions over which a mean is taken. This is
// applied as a constant value over the adjacent end "frequency correction"
// regions.
//
// low_mean_start_bin_ high_mean_start_bin_
@ -261,37 +237,71 @@ void NonlinearBeamformer::InitFrequencyCorrectionRanges() {
// constant ^ ^
// low_mean_end_bin_ high_mean_end_bin_
//
void NonlinearBeamformer::InitLowFrequencyCorrectionRanges() {
low_mean_start_bin_ = Round(kLowMeanStartHz * kFftSize / sample_rate_hz_);
low_mean_end_bin_ = Round(kLowMeanEndHz * kFftSize / sample_rate_hz_);
RTC_DCHECK_GT(low_mean_start_bin_, 0U);
RTC_DCHECK_LT(low_mean_start_bin_, low_mean_end_bin_);
}
void NonlinearBeamformer::InitHighFrequencyCorrectionRanges() {
const float kAliasingFreqHz =
kSpeedOfSoundMeterSeconds /
(min_mic_spacing_ * (1.f + std::abs(std::cos(target_angle_radians_))));
const float kHighMeanStartHz = std::min(0.5f * kAliasingFreqHz,
sample_rate_hz_ / 2.f);
const float kHighMeanEndHz = std::min(0.75f * kAliasingFreqHz,
sample_rate_hz_ / 2.f);
high_mean_start_bin_ = Round(kHighMeanStartHz * kFftSize / sample_rate_hz_);
high_mean_end_bin_ = Round(kHighMeanEndHz * kFftSize / sample_rate_hz_);
RTC_DCHECK_LT(low_mean_end_bin_, high_mean_end_bin_);
RTC_DCHECK_LT(high_mean_start_bin_, high_mean_end_bin_);
RTC_DCHECK_LT(high_mean_end_bin_, kNumFreqBins - 1);
}
void NonlinearBeamformer::InitInterfAngles() {
const float kAwayRadians =
std::min(static_cast<float>(M_PI),
std::max(kMinAwayRadians, kAwaySlope * static_cast<float>(M_PI) /
min_mic_spacing_));
interf_angles_radians_.clear();
// TODO(aluebs): When the target angle is settable, make sure the interferer
// scenarios aren't reflected over the target one for linear geometries.
interf_angles_radians_.push_back(kTargetAngleRadians - kAwayRadians);
interf_angles_radians_.push_back(kTargetAngleRadians + kAwayRadians);
const Point target_direction = AzimuthToPoint(target_angle_radians_);
const Point clockwise_interf_direction =
AzimuthToPoint(target_angle_radians_ - away_radians_);
if (!array_normal_ ||
DotProduct(*array_normal_, target_direction) *
DotProduct(*array_normal_, clockwise_interf_direction) >=
0.f) {
// The target and clockwise interferer are in the same half-plane defined
// by the array.
interf_angles_radians_.push_back(target_angle_radians_ - away_radians_);
} else {
// Otherwise, the interferer will begin reflecting back at the target.
// Instead rotate it away 180 degrees.
interf_angles_radians_.push_back(target_angle_radians_ - away_radians_ +
M_PI);
}
const Point counterclock_interf_direction =
AzimuthToPoint(target_angle_radians_ + away_radians_);
if (!array_normal_ ||
DotProduct(*array_normal_, target_direction) *
DotProduct(*array_normal_, counterclock_interf_direction) >=
0.f) {
// The target and counter-clockwise interferer are in the same half-plane
// defined by the array.
interf_angles_radians_.push_back(target_angle_radians_ + away_radians_);
} else {
// Otherwise, the interferer will begin reflecting back at the target.
// Instead rotate it away 180 degrees.
interf_angles_radians_.push_back(target_angle_radians_ + away_radians_ -
M_PI);
}
}
void NonlinearBeamformer::InitDelaySumMasks() {
for (size_t f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
delay_sum_masks_[f_ix].Resize(1, num_input_channels_);
CovarianceMatrixGenerator::PhaseAlignmentMasks(f_ix,
kFftSize,
sample_rate_hz_,
kSpeedOfSoundMeterSeconds,
array_geometry_,
kTargetAngleRadians,
&delay_sum_masks_[f_ix]);
CovarianceMatrixGenerator::PhaseAlignmentMasks(
f_ix, kFftSize, sample_rate_hz_, kSpeedOfSoundMeterSeconds,
array_geometry_, target_angle_radians_, &delay_sum_masks_[f_ix]);
complex_f norm_factor = sqrt(
ConjugateDotProduct(delay_sum_masks_[f_ix], delay_sum_masks_[f_ix]));
@ -309,15 +319,19 @@ void NonlinearBeamformer::InitTargetCovMats() {
}
}
void NonlinearBeamformer::InitDiffuseCovMats() {
for (size_t i = 0; i < kNumFreqBins; ++i) {
uniform_cov_mat_[i].Resize(num_input_channels_, num_input_channels_);
CovarianceMatrixGenerator::UniformCovarianceMatrix(
wave_numbers_[i], array_geometry_, &uniform_cov_mat_[i]);
complex_f normalization_factor = uniform_cov_mat_[i].elements()[0][0];
uniform_cov_mat_[i].Scale(1.f / normalization_factor);
uniform_cov_mat_[i].Scale(1 - kBalance);
}
}
void NonlinearBeamformer::InitInterfCovMats() {
for (size_t i = 0; i < kNumFreqBins; ++i) {
ComplexMatrixF uniform_cov_mat(num_input_channels_, num_input_channels_);
CovarianceMatrixGenerator::UniformCovarianceMatrix(wave_numbers_[i],
array_geometry_,
&uniform_cov_mat);
complex_f normalization_factor = uniform_cov_mat.elements()[0][0];
uniform_cov_mat.Scale(1.f / normalization_factor);
uniform_cov_mat.Scale(1 - kBalance);
interf_cov_mats_[i].clear();
for (size_t j = 0; j < interf_angles_radians_.size(); ++j) {
interf_cov_mats_[i].push_back(new ComplexMatrixF(num_input_channels_,
@ -333,11 +347,21 @@ void NonlinearBeamformer::InitInterfCovMats() {
array_geometry_,
&angled_cov_mat);
// Normalize matrices before averaging them.
normalization_factor = angled_cov_mat.elements()[0][0];
complex_f normalization_factor = angled_cov_mat.elements()[0][0];
angled_cov_mat.Scale(1.f / normalization_factor);
// Weighted average of matrices.
angled_cov_mat.Scale(kBalance);
interf_cov_mats_[i][j]->Add(uniform_cov_mat, angled_cov_mat);
interf_cov_mats_[i][j]->Add(uniform_cov_mat_[i], angled_cov_mat);
}
}
}
void NonlinearBeamformer::NormalizeCovMats() {
for (size_t i = 0; i < kNumFreqBins; ++i) {
rxiws_[i] = Norm(target_cov_mats_[i], delay_sum_masks_[i]);
rpsiws_[i].clear();
for (size_t j = 0; j < interf_angles_radians_.size(); ++j) {
rpsiws_[i].push_back(Norm(*interf_cov_mats_[i][j], delay_sum_masks_[i]));
}
}
}
@ -354,28 +378,32 @@ void NonlinearBeamformer::ProcessChunk(const ChannelBuffer<float>& input,
const float ramp_increment =
(high_pass_postfilter_mask_ - old_high_pass_mask) /
input.num_frames_per_band();
// Apply delay and sum and post-filter in the time domain. WARNING: only works
// because delay-and-sum is not frequency dependent.
// Apply the smoothed high-pass mask to the first channel of each band.
// This can be done because the effct of the linear beamformer is negligible
// compared to the post-filter.
for (size_t i = 1; i < input.num_bands(); ++i) {
float smoothed_mask = old_high_pass_mask;
for (size_t j = 0; j < input.num_frames_per_band(); ++j) {
smoothed_mask += ramp_increment;
output->channels(i)[0][j] = input.channels(i)[0][j] * smoothed_mask;
}
}
}
// Applying the delay and sum (at zero degrees, this is equivalent to
// averaging).
float sum = 0.f;
for (int k = 0; k < input.num_channels(); ++k) {
sum += input.channels(i)[k][j];
}
output->channels(i)[0][j] = sum / input.num_channels() * smoothed_mask;
}
}
void NonlinearBeamformer::AimAt(const SphericalPointf& target_direction) {
target_angle_radians_ = target_direction.azimuth();
InitHighFrequencyCorrectionRanges();
InitInterfAngles();
InitDelaySumMasks();
InitTargetCovMats();
InitInterfCovMats();
NormalizeCovMats();
}
bool NonlinearBeamformer::IsInBeam(const SphericalPointf& spherical_point) {
// If more than half-beamwidth degrees away from the beam's center,
// you are out of the beam.
return fabs(spherical_point.azimuth() - kTargetAngleRadians) <
return fabs(spherical_point.azimuth() - target_angle_radians_) <
kHalfBeamWidthRadians;
}

30
webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.h
View File

@ -11,6 +11,10 @@
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_BEAMFORMER_NONLINEAR_BEAMFORMER_H_
#define WEBRTC_MODULES_AUDIO_PROCESSING_BEAMFORMER_NONLINEAR_BEAMFORMER_H_
// MSVC++ requires this to be set before any other includes to get M_PI.
#define _USE_MATH_DEFINES
#include <math.h>
#include <vector>
#include "webrtc/common_audio/lapped_transform.h"
@ -31,7 +35,12 @@ class NonlinearBeamformer
: public Beamformer<float>,
public LappedTransform::Callback {
public:
explicit NonlinearBeamformer(const std::vector<Point>& array_geometry);
static const float kHalfBeamWidthRadians;
explicit NonlinearBeamformer(
const std::vector<Point>& array_geometry,
SphericalPointf target_direction =
SphericalPointf(static_cast<float>(M_PI) / 2.f, 0.f, 1.f));
// Sample rate corresponds to the lower band.
// Needs to be called before the NonlinearBeamformer can be used.
@ -44,6 +53,8 @@ class NonlinearBeamformer
void ProcessChunk(const ChannelBuffer<float>& input,
ChannelBuffer<float>* output) override;
void AimAt(const SphericalPointf& target_direction) override;
bool IsInBeam(const SphericalPointf& spherical_point) override;
// After processing each block |is_target_present_| is set to true if the
@ -62,15 +73,21 @@ class NonlinearBeamformer
complex<float>* const* output) override;
private:
FRIEND_TEST_ALL_PREFIXES(NonlinearBeamformerTest,
InterfAnglesTakeAmbiguityIntoAccount);
typedef Matrix<float> MatrixF;
typedef ComplexMatrix<float> ComplexMatrixF;
typedef complex<float> complex_f;
void InitFrequencyCorrectionRanges();
void InitLowFrequencyCorrectionRanges();
void InitHighFrequencyCorrectionRanges();
void InitInterfAngles();
void InitDelaySumMasks();
void InitTargetCovMats();
void InitDiffuseCovMats();
void InitInterfCovMats();
void NormalizeCovMats();
// Calculates postfilter masks that minimize the mean squared error of our
// estimation of the desired signal.
@ -116,6 +133,8 @@ class NonlinearBeamformer
int sample_rate_hz_;
const std::vector<Point> array_geometry_;
// The normal direction of the array if it has one and it is in the xy-plane.
const rtc::Maybe<Point> array_normal_;
// Minimum spacing between microphone pairs.
const float min_mic_spacing_;
@ -133,17 +152,20 @@ class NonlinearBeamformer
// Time and frequency smoothed mask.
float final_mask_[kNumFreqBins];
float target_angle_radians_;
// Angles of the interferer scenarios.
std::vector<float> interf_angles_radians_;
// The angle between the target and the interferer scenarios.
const float away_radians_;
// Array of length |kNumFreqBins|, Matrix of size |1| x |num_channels_|.
ComplexMatrixF delay_sum_masks_[kNumFreqBins];
ComplexMatrixF normalized_delay_sum_masks_[kNumFreqBins];
// Array of length |kNumFreqBins|, Matrix of size |num_input_channels_| x
// Arrays of length |kNumFreqBins|, Matrix of size |num_input_channels_| x
// |num_input_channels_|.
ComplexMatrixF target_cov_mats_[kNumFreqBins];
ComplexMatrixF uniform_cov_mat_[kNumFreqBins];
// Array of length |kNumFreqBins|, Matrix of size |num_input_channels_| x
// |num_input_channels_|. ScopedVector has a size equal to the number of
// interferer scenarios.

147
webrtc/modules/audio_processing/beamformer/nonlinear_beamformer_unittest.cc Normal file
View File

@ -0,0 +1,147 @@
/*
* Copyright (c) 2015 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.
*/
// MSVC++ requires this to be set before any other includes to get M_PI.
#define _USE_MATH_DEFINES
#include "webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.h"
#include <math.h>
#include "testing/gtest/include/gtest/gtest.h"
namespace webrtc {
namespace {
const int kChunkSizeMs = 10;
const int kSampleRateHz = 16000;
SphericalPointf AzimuthToSphericalPoint(float azimuth_radians) {
return SphericalPointf(azimuth_radians, 0.f, 1.f);
}
void Verify(NonlinearBeamformer* bf, float target_azimuth_radians) {
EXPECT_TRUE(bf->IsInBeam(AzimuthToSphericalPoint(target_azimuth_radians)));
EXPECT_TRUE(bf->IsInBeam(AzimuthToSphericalPoint(
target_azimuth_radians - NonlinearBeamformer::kHalfBeamWidthRadians +
0.001f)));
EXPECT_TRUE(bf->IsInBeam(AzimuthToSphericalPoint(
target_azimuth_radians + NonlinearBeamformer::kHalfBeamWidthRadians -
0.001f)));
EXPECT_FALSE(bf->IsInBeam(AzimuthToSphericalPoint(
target_azimuth_radians - NonlinearBeamformer::kHalfBeamWidthRadians -
0.001f)));
EXPECT_FALSE(bf->IsInBeam(AzimuthToSphericalPoint(
target_azimuth_radians + NonlinearBeamformer::kHalfBeamWidthRadians +
0.001f)));
}
void AimAndVerify(NonlinearBeamformer* bf, float target_azimuth_radians) {
bf->AimAt(AzimuthToSphericalPoint(target_azimuth_radians));
Verify(bf, target_azimuth_radians);
}
} // namespace
TEST(NonlinearBeamformerTest, AimingModifiesBeam) {
std::vector<Point> array_geometry;
array_geometry.push_back(Point(-0.025f, 0.f, 0.f));
array_geometry.push_back(Point(0.025f, 0.f, 0.f));
NonlinearBeamformer bf(array_geometry);
bf.Initialize(kChunkSizeMs, kSampleRateHz);
// The default constructor parameter sets the target angle to PI / 2.
Verify(&bf, static_cast<float>(M_PI) / 2.f);
AimAndVerify(&bf, static_cast<float>(M_PI) / 3.f);
AimAndVerify(&bf, 3.f * static_cast<float>(M_PI) / 4.f);
AimAndVerify(&bf, static_cast<float>(M_PI) / 6.f);
AimAndVerify(&bf, static_cast<float>(M_PI));
}
TEST(NonlinearBeamformerTest, InterfAnglesTakeAmbiguityIntoAccount) {
{
// For linear arrays there is ambiguity.
std::vector<Point> array_geometry;
array_geometry.push_back(Point(-0.1f, 0.f, 0.f));
array_geometry.push_back(Point(0.f, 0.f, 0.f));
array_geometry.push_back(Point(0.2f, 0.f, 0.f));
NonlinearBeamformer bf(array_geometry);
bf.Initialize(kChunkSizeMs, kSampleRateHz);
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
bf.interf_angles_radians_[1]);
bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f,
bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
}
{
// For planar arrays with normal in the xy-plane there is ambiguity.
std::vector<Point> array_geometry;
array_geometry.push_back(Point(-0.1f, 0.f, 0.f));
array_geometry.push_back(Point(0.f, 0.f, 0.f));
array_geometry.push_back(Point(0.2f, 0.f, 0.f));
array_geometry.push_back(Point(0.1f, 0.f, 0.2f));
array_geometry.push_back(Point(0.f, 0.f, -0.1f));
NonlinearBeamformer bf(array_geometry);
bf.Initialize(kChunkSizeMs, kSampleRateHz);
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
bf.interf_angles_radians_[1]);
bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f,
bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
}
{
// For planar arrays with normal not in the xy-plane there is no ambiguity.
std::vector<Point> array_geometry;
array_geometry.push_back(Point(0.f, 0.f, 0.f));
array_geometry.push_back(Point(0.2f, 0.f, 0.f));
array_geometry.push_back(Point(0.f, 0.1f, -0.2f));
NonlinearBeamformer bf(array_geometry);
bf.Initialize(kChunkSizeMs, kSampleRateHz);
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
bf.interf_angles_radians_[1]);
bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
}
{
// For arrays which are not linear or planar there is no ambiguity.
std::vector<Point> array_geometry;
array_geometry.push_back(Point(0.f, 0.f, 0.f));
array_geometry.push_back(Point(0.1f, 0.f, 0.f));
array_geometry.push_back(Point(0.f, 0.2f, 0.f));
array_geometry.push_back(Point(0.f, 0.f, 0.3f));
NonlinearBeamformer bf(array_geometry);
bf.Initialize(kChunkSizeMs, kSampleRateHz);
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
bf.interf_angles_radians_[1]);
bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
EXPECT_EQ(2u, bf.interf_angles_radians_.size());
EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]);
EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
}
}
} // namespace webrtc

19
webrtc/modules/audio_processing/include/audio_processing.h
View File

@ -11,6 +11,10 @@
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_
#define WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_
// MSVC++ requires this to be set before any other includes to get M_PI.
#define _USE_MATH_DEFINES
#include <math.h>
#include <stddef.h> // size_t
#include <stdio.h> // FILE
#include <vector>
@ -109,12 +113,23 @@ struct ExperimentalNs {
struct Beamforming {
Beamforming()
: enabled(false),
array_geometry() {}
array_geometry(),
target_direction(
SphericalPointf(static_cast<float>(M_PI) / 2.f, 0.f, 1.f)) {}
Beamforming(bool enabled, const std::vector<Point>& array_geometry)
: Beamforming(enabled,
array_geometry,
SphericalPointf(static_cast<float>(M_PI) / 2.f, 0.f, 1.f)) {
}
Beamforming(bool enabled,
const std::vector<Point>& array_geometry,
SphericalPointf target_direction)
: enabled(enabled),
array_geometry(array_geometry) {}
array_geometry(array_geometry),
target_direction(target_direction) {}
const bool enabled;
const std::vector<Point> array_geometry;
const SphericalPointf target_direction;
};
// Use to enable intelligibility enhancer in audio processing. Must be provided

6
webrtc/modules/audio_processing/test/audioproc_float.cc
View File

@ -37,6 +37,7 @@ DEFINE_string(mic_positions, "",
"Space delimited cartesian coordinates of microphones in meters. "
"The coordinates of each point are contiguous. "
"For a two element array: \"x1 y1 z1 x2 y2 z2\"");
DEFINE_double(target_angle_degrees, 90, "The azimuth of the target in radians");
DEFINE_bool(aec, false, "Enable echo cancellation.");
DEFINE_bool(agc, false, "Enable automatic gain control.");
@ -107,7 +108,10 @@ int main(int argc, char* argv[]) {
ParseArrayGeometry(FLAGS_mic_positions, num_mics);
RTC_CHECK_EQ(array_geometry.size(), num_mics);
config.Set<Beamforming>(new Beamforming(true, array_geometry));
config.Set<Beamforming>(new Beamforming(
true, array_geometry,
SphericalPointf(DegreesToRadians(FLAGS_target_angle_degrees), 0.f,
1.f)));
}
rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create(config));

1
webrtc/modules/modules.gyp
View File

@ -171,6 +171,7 @@
'audio_processing/beamformer/covariance_matrix_generator_unittest.cc',
'audio_processing/beamformer/matrix_unittest.cc',
'audio_processing/beamformer/mock_nonlinear_beamformer.h',
'audio_processing/beamformer/nonlinear_beamformer_unittest.cc',
'audio_processing/echo_cancellation_impl_unittest.cc',
'audio_processing/intelligibility/intelligibility_enhancer_unittest.cc',
'audio_processing/intelligibility/intelligibility_utils_unittest.cc',