modules/audio_processing/aec3/subtractor_unittest.cc - src.git - Git at Google

 /*
  *  Copyright (c) 2017 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/subtractor.h"

 #include <algorithm>
 #include <numeric>
 #include <string>

 #include "modules/audio_processing/aec3/aec_state.h"
 #include "modules/audio_processing/aec3/render_delay_buffer.h"
 #include "modules/audio_processing/test/echo_canceller_test_tools.h"
 #include "rtc_base/random.h"
 #include "rtc_base/strings/string_builder.h"
 #include "test/gtest.h"

 namespace webrtc {
 namespace {

 float RunSubtractorTest(int num_blocks_to_process,
                         int delay_samples,
                         int main_filter_length_blocks,
                         int shadow_filter_length_blocks,
                         bool uncorrelated_inputs,
                         const std::vector<int>& blocks_with_echo_path_changes) {
   ApmDataDumper data_dumper(42);
   EchoCanceller3Config config;
   config.filter.main.length_blocks = main_filter_length_blocks;
   config.filter.shadow.length_blocks = shadow_filter_length_blocks;

   Subtractor subtractor(config, &data_dumper, DetectOptimization());
   absl::optional<DelayEstimate> delay_estimate;
   std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
   std::vector<float> y(kBlockSize, 0.f);
   std::array<float, kBlockSize> x_old;
   SubtractorOutput output;
   config.delay.min_echo_path_delay_blocks = 0;
   config.delay.default_delay = 1;
   std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
       RenderDelayBuffer::Create(config, 3));
   RenderSignalAnalyzer render_signal_analyzer(config);
   Random random_generator(42U);
   Aec3Fft fft;
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kFftLengthBy2Plus1> E2_main;
   std::array<float, kFftLengthBy2Plus1> E2_shadow;
   AecState aec_state(config);
   x_old.fill(0.f);
   Y2.fill(0.f);
   E2_main.fill(0.f);
   E2_shadow.fill(0.f);

   DelayBuffer<float> delay_buffer(delay_samples);
   for (int k = 0; k < num_blocks_to_process; ++k) {
     RandomizeSampleVector(&random_generator, x[0]);
     if (uncorrelated_inputs) {
       RandomizeSampleVector(&random_generator, y);
     } else {
       delay_buffer.Delay(x[0], y);
     }
     render_delay_buffer->Insert(x);
     if (k == 0) {
       render_delay_buffer->Reset();
     }
     render_delay_buffer->PrepareCaptureProcessing();
     render_signal_analyzer.Update(*render_delay_buffer->GetRenderBuffer(),
                                   aec_state.FilterDelayBlocks());

     // Handle echo path changes.
     if (std::find(blocks_with_echo_path_changes.begin(),
                   blocks_with_echo_path_changes.end(),
                   k) != blocks_with_echo_path_changes.end()) {
       subtractor.HandleEchoPathChange(EchoPathVariability(
           true, EchoPathVariability::DelayAdjustment::kNewDetectedDelay,
           false));
     }
     subtractor.Process(*render_delay_buffer->GetRenderBuffer(), y,
                        render_signal_analyzer, aec_state, &output);

     aec_state.HandleEchoPathChange(EchoPathVariability(
         false, EchoPathVariability::DelayAdjustment::kNone, false));
     aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse(),
                      subtractor.FilterImpulseResponse(),
                      *render_delay_buffer->GetRenderBuffer(), E2_main, Y2,
                      output, y);
   }

   const float output_power = std::inner_product(
       output.e_main.begin(), output.e_main.end(), output.e_main.begin(), 0.f);
   const float y_power = std::inner_product(y.begin(), y.end(), y.begin(), 0.f);
   if (y_power == 0.f) {
     ADD_FAILURE();
     return -1.0;
   }
   return output_power / y_power;
 }

 std::string ProduceDebugText(size_t delay, int filter_length_blocks) {
   rtc::StringBuilder ss;
   ss << "Delay: " << delay << ", ";
   ss << "Length: " << filter_length_blocks;
   return ss.str();
 }

 }  // namespace

 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)

 // Verifies that the check for non data dumper works.
 TEST(Subtractor, NullDataDumper) {
   EXPECT_DEATH(
       Subtractor(EchoCanceller3Config(), nullptr, DetectOptimization()), "");
 }

 // Verifies the check for null subtractor output.
 // TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
 // tests on test bots has been fixed.
 TEST(Subtractor, DISABLED_NullOutput) {
   ApmDataDumper data_dumper(42);
   EchoCanceller3Config config;
   Subtractor subtractor(config, &data_dumper, DetectOptimization());
   std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
       RenderDelayBuffer::Create(config, 3));
   RenderSignalAnalyzer render_signal_analyzer(config);
   std::vector<float> y(kBlockSize, 0.f);

   EXPECT_DEATH(
       subtractor.Process(*render_delay_buffer->GetRenderBuffer(), y,
                          render_signal_analyzer, AecState(config), nullptr),
       "");
 }

 // Verifies the check for the capture signal size.
 TEST(Subtractor, WrongCaptureSize) {
   ApmDataDumper data_dumper(42);
   EchoCanceller3Config config;
   Subtractor subtractor(config, &data_dumper, DetectOptimization());
   std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
       RenderDelayBuffer::Create(config, 3));
   RenderSignalAnalyzer render_signal_analyzer(config);
   std::vector<float> y(kBlockSize - 1, 0.f);
   SubtractorOutput output;

   EXPECT_DEATH(
       subtractor.Process(*render_delay_buffer->GetRenderBuffer(), y,
                          render_signal_analyzer, AecState(config), &output),
       "");
 }

 #endif

 // Verifies that the subtractor is able to converge on correlated data.
 TEST(Subtractor, Convergence) {
   std::vector<int> blocks_with_echo_path_changes;
   for (size_t filter_length_blocks : {12, 20, 30}) {
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
       SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));

       float echo_to_nearend_power = RunSubtractorTest(
           400, delay_samples, filter_length_blocks, filter_length_blocks, false,
           blocks_with_echo_path_changes);

       // Use different criteria to take overmodelling into account.
       if (filter_length_blocks == 12) {
         EXPECT_GT(0.1f, echo_to_nearend_power);
       } else {
         EXPECT_GT(1.f, echo_to_nearend_power);
       }
     }
   }
 }

 // Verifies that the subtractor is able to handle the case when the main filter
 // is longer than the shadow filter.
 TEST(Subtractor, MainFilterLongerThanShadowFilter) {
   std::vector<int> blocks_with_echo_path_changes;
   float echo_to_nearend_power =
       RunSubtractorTest(400, 64, 20, 15, false, blocks_with_echo_path_changes);
   EXPECT_GT(0.5f, echo_to_nearend_power);
 }

 // Verifies that the subtractor is able to handle the case when the shadow
 // filter is longer than the main filter.
 TEST(Subtractor, ShadowFilterLongerThanMainFilter) {
   std::vector<int> blocks_with_echo_path_changes;
   float echo_to_nearend_power =
       RunSubtractorTest(400, 64, 15, 20, false, blocks_with_echo_path_changes);
   EXPECT_GT(0.5f, echo_to_nearend_power);
 }

 // Verifies that the subtractor does not converge on uncorrelated signals.
 TEST(Subtractor, NonConvergenceOnUncorrelatedSignals) {
   std::vector<int> blocks_with_echo_path_changes;
   for (size_t filter_length_blocks : {12, 20, 30}) {
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
       SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));

       float echo_to_nearend_power = RunSubtractorTest(
           300, delay_samples, filter_length_blocks, filter_length_blocks, true,
           blocks_with_echo_path_changes);
       EXPECT_NEAR(1.f, echo_to_nearend_power, 0.1);
     }
   }
 }

 // Verifies that the subtractor is properly reset when there is an echo path
 // change.
 TEST(Subtractor, EchoPathChangeReset) {
   std::vector<int> blocks_with_echo_path_changes;
   blocks_with_echo_path_changes.push_back(99);
   for (size_t filter_length_blocks : {12, 20, 30}) {
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
       SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));

       float echo_to_nearend_power = RunSubtractorTest(
           100, delay_samples, filter_length_blocks, filter_length_blocks, false,
           blocks_with_echo_path_changes);
       EXPECT_NEAR(1.f, echo_to_nearend_power, 0.0000001f);
     }
   }
 }

 }  // namespace webrtc
	/*
	* Copyright (c) 2017 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/subtractor.h"

	#include <algorithm>
	#include <numeric>
	#include <string>

	#include "modules/audio_processing/aec3/aec_state.h"
	#include "modules/audio_processing/aec3/render_delay_buffer.h"
	#include "modules/audio_processing/test/echo_canceller_test_tools.h"
	#include "rtc_base/random.h"
	#include "rtc_base/strings/string_builder.h"
	#include "test/gtest.h"

	namespace webrtc {
	namespace {

	float RunSubtractorTest(int num_blocks_to_process,
	int delay_samples,
	int main_filter_length_blocks,
	int shadow_filter_length_blocks,
	bool uncorrelated_inputs,
	const std::vector<int>& blocks_with_echo_path_changes) {
	ApmDataDumper data_dumper(42);
	EchoCanceller3Config config;
	config.filter.main.length_blocks = main_filter_length_blocks;
	config.filter.shadow.length_blocks = shadow_filter_length_blocks;

	Subtractor subtractor(config, &data_dumper, DetectOptimization());
	absl::optional<DelayEstimate> delay_estimate;
	std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
	std::vector<float> y(kBlockSize, 0.f);
	std::array<float, kBlockSize> x_old;
	SubtractorOutput output;
	config.delay.min_echo_path_delay_blocks = 0;
	config.delay.default_delay = 1;
	std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
	RenderDelayBuffer::Create(config, 3));
	RenderSignalAnalyzer render_signal_analyzer(config);
	Random random_generator(42U);
	Aec3Fft fft;
	std::array<float, kFftLengthBy2Plus1> Y2;
	std::array<float, kFftLengthBy2Plus1> E2_main;
	std::array<float, kFftLengthBy2Plus1> E2_shadow;
	AecState aec_state(config);
	x_old.fill(0.f);
	Y2.fill(0.f);
	E2_main.fill(0.f);
	E2_shadow.fill(0.f);

	DelayBuffer<float> delay_buffer(delay_samples);
	for (int k = 0; k < num_blocks_to_process; ++k) {
	RandomizeSampleVector(&random_generator, x[0]);
	if (uncorrelated_inputs) {
	RandomizeSampleVector(&random_generator, y);
	} else {
	delay_buffer.Delay(x[0], y);
	}
	render_delay_buffer->Insert(x);
	if (k == 0) {
	render_delay_buffer->Reset();
	}
	render_delay_buffer->PrepareCaptureProcessing();
	render_signal_analyzer.Update(*render_delay_buffer->GetRenderBuffer(),
	aec_state.FilterDelayBlocks());

	// Handle echo path changes.
	if (std::find(blocks_with_echo_path_changes.begin(),
	blocks_with_echo_path_changes.end(),
	k) != blocks_with_echo_path_changes.end()) {
	subtractor.HandleEchoPathChange(EchoPathVariability(
	true, EchoPathVariability::DelayAdjustment::kNewDetectedDelay,
	false));
	}
	subtractor.Process(*render_delay_buffer->GetRenderBuffer(), y,
	render_signal_analyzer, aec_state, &output);

	aec_state.HandleEchoPathChange(EchoPathVariability(
	false, EchoPathVariability::DelayAdjustment::kNone, false));
	aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse(),
	subtractor.FilterImpulseResponse(),
	*render_delay_buffer->GetRenderBuffer(), E2_main, Y2,
	output, y);
	}

	const float output_power = std::inner_product(
	output.e_main.begin(), output.e_main.end(), output.e_main.begin(), 0.f);
	const float y_power = std::inner_product(y.begin(), y.end(), y.begin(), 0.f);
	if (y_power == 0.f) {
	ADD_FAILURE();
	return -1.0;
	}
	return output_power / y_power;
	}

	std::string ProduceDebugText(size_t delay, int filter_length_blocks) {
	rtc::StringBuilder ss;
	ss << "Delay: " << delay << ", ";
	ss << "Length: " << filter_length_blocks;
	return ss.str();
	}

	} // namespace

	#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)

	// Verifies that the check for non data dumper works.
	TEST(Subtractor, NullDataDumper) {
	EXPECT_DEATH(
	Subtractor(EchoCanceller3Config(), nullptr, DetectOptimization()), "");
	}

	// Verifies the check for null subtractor output.
	// TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
	// tests on test bots has been fixed.
	TEST(Subtractor, DISABLED_NullOutput) {
	ApmDataDumper data_dumper(42);
	EchoCanceller3Config config;
	Subtractor subtractor(config, &data_dumper, DetectOptimization());
	std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
	RenderDelayBuffer::Create(config, 3));
	RenderSignalAnalyzer render_signal_analyzer(config);
	std::vector<float> y(kBlockSize, 0.f);

	EXPECT_DEATH(
	subtractor.Process(*render_delay_buffer->GetRenderBuffer(), y,
	render_signal_analyzer, AecState(config), nullptr),
	"");
	}

	// Verifies the check for the capture signal size.
	TEST(Subtractor, WrongCaptureSize) {
	ApmDataDumper data_dumper(42);
	EchoCanceller3Config config;
	Subtractor subtractor(config, &data_dumper, DetectOptimization());
	std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
	RenderDelayBuffer::Create(config, 3));
	RenderSignalAnalyzer render_signal_analyzer(config);
	std::vector<float> y(kBlockSize - 1, 0.f);
	SubtractorOutput output;

	EXPECT_DEATH(
	subtractor.Process(*render_delay_buffer->GetRenderBuffer(), y,
	render_signal_analyzer, AecState(config), &output),
	"");
	}

	#endif

	// Verifies that the subtractor is able to converge on correlated data.
	TEST(Subtractor, Convergence) {
	std::vector<int> blocks_with_echo_path_changes;
	for (size_t filter_length_blocks : {12, 20, 30}) {
	for (size_t delay_samples : {0, 64, 150, 200, 301}) {
	SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));

	float echo_to_nearend_power = RunSubtractorTest(
	400, delay_samples, filter_length_blocks, filter_length_blocks, false,
	blocks_with_echo_path_changes);

	// Use different criteria to take overmodelling into account.
	if (filter_length_blocks == 12) {
	EXPECT_GT(0.1f, echo_to_nearend_power);
	} else {
	EXPECT_GT(1.f, echo_to_nearend_power);
	}
	}
	}
	}

	// Verifies that the subtractor is able to handle the case when the main filter
	// is longer than the shadow filter.
	TEST(Subtractor, MainFilterLongerThanShadowFilter) {
	std::vector<int> blocks_with_echo_path_changes;
	float echo_to_nearend_power =
	RunSubtractorTest(400, 64, 20, 15, false, blocks_with_echo_path_changes);
	EXPECT_GT(0.5f, echo_to_nearend_power);
	}

	// Verifies that the subtractor is able to handle the case when the shadow
	// filter is longer than the main filter.
	TEST(Subtractor, ShadowFilterLongerThanMainFilter) {
	std::vector<int> blocks_with_echo_path_changes;
	float echo_to_nearend_power =
	RunSubtractorTest(400, 64, 15, 20, false, blocks_with_echo_path_changes);
	EXPECT_GT(0.5f, echo_to_nearend_power);
	}

	// Verifies that the subtractor does not converge on uncorrelated signals.
	TEST(Subtractor, NonConvergenceOnUncorrelatedSignals) {
	std::vector<int> blocks_with_echo_path_changes;
	for (size_t filter_length_blocks : {12, 20, 30}) {
	for (size_t delay_samples : {0, 64, 150, 200, 301}) {
	SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));

	float echo_to_nearend_power = RunSubtractorTest(
	300, delay_samples, filter_length_blocks, filter_length_blocks, true,
	blocks_with_echo_path_changes);
	EXPECT_NEAR(1.f, echo_to_nearend_power, 0.1);
	}
	}
	}

	// Verifies that the subtractor is properly reset when there is an echo path
	// change.
	TEST(Subtractor, EchoPathChangeReset) {
	std::vector<int> blocks_with_echo_path_changes;
	blocks_with_echo_path_changes.push_back(99);
	for (size_t filter_length_blocks : {12, 20, 30}) {
	for (size_t delay_samples : {0, 64, 150, 200, 301}) {
	SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));

	float echo_to_nearend_power = RunSubtractorTest(
	100, delay_samples, filter_length_blocks, filter_length_blocks, false,
	blocks_with_echo_path_changes);
	EXPECT_NEAR(1.f, echo_to_nearend_power, 0.0000001f);
	}
	}
	}

	} // namespace webrtc