Compensate for the compression gain in the IntelligibilityEnhancer

webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc

 /*
  *  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.
  */
 
@@ skipping 219 matching lines @@
 
   intelligibility_enhancer->ProcessRenderAudio(
       render_audio_buffer->split_channels_f(kBand0To8kHz),
       IntelligibilityEnhancerSampleRate(sample_rate_hz),
       render_audio_buffer->num_channels());
 
   noise_suppressor->AnalyzeCaptureAudio(capture_audio_buffer);
   noise_suppressor->ProcessCaptureAudio(capture_audio_buffer);
 
   intelligibility_enhancer->SetCaptureNoiseEstimate(
-      noise_suppressor->NoiseEstimate());
+      noise_suppressor->NoiseEstimate(), 0);
 
   if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
     render_audio_buffer->MergeFrequencyBands();
   }
 }
 
 // Processes a specified amount of frames, verifies the results and reports
 // any errors.
 void RunBitexactnessTest(int sample_rate_hz,
                          size_t num_channels,
@@ skipping 53 matching lines @@
   // Compare the output with the reference. Only the first values of the output
   // from last frame processed are compared in order not having to specify all
   // preceeding frames as testvectors. As the algorithm being tested has a
   // memory, testing only the last frame implicitly also tests the preceeding
   // frames.
   EXPECT_TRUE(test::VerifyDeinterleavedArray(
       render_buffer.num_frames(), render_config.num_channels(),
       output_reference, render_output, kElementErrorBound));
 }
 
+float float_rand() {
+  return std::rand() * 2.f / RAND_MAX - 1;
+}
+
 }  // namespace
 
 class IntelligibilityEnhancerTest : public ::testing::Test {
  protected:
   IntelligibilityEnhancerTest()
       : clear_data_(kSamples), noise_data_(kSamples), orig_data_(kSamples) {
+    std::srand(1);
     enh_.reset(
         new IntelligibilityEnhancer(kSampleRate, kNumChannels, kNumNoiseBins));
   }
 
   bool CheckUpdate() {
     enh_.reset(
         new IntelligibilityEnhancer(kSampleRate, kNumChannels, kNumNoiseBins));
     float* clear_cursor = clear_data_.data();
     float* noise_cursor = noise_data_.data();
     for (int i = 0; i < kSamples; i += kFragmentSize) {
@@ skipping 15 matching lines @@
   std::vector<float> orig_data_;
 };
 
 // For each class of generated data, tests that render stream is updated when
 // it should be.
 TEST_F(IntelligibilityEnhancerTest, TestRenderUpdate) {
   std::fill(noise_data_.begin(), noise_data_.end(), 0.f);
   std::fill(orig_data_.begin(), orig_data_.end(), 0.f);
   std::fill(clear_data_.begin(), clear_data_.end(), 0.f);
   EXPECT_FALSE(CheckUpdate());
-  std::srand(1);
-  auto float_rand = []() { return std::rand() * 2.f / RAND_MAX - 1; };
   std::generate(noise_data_.begin(), noise_data_.end(), float_rand);
   EXPECT_FALSE(CheckUpdate());
   std::generate(clear_data_.begin(), clear_data_.end(), float_rand);
   orig_data_ = clear_data_;
   EXPECT_TRUE(CheckUpdate());
 }
 
 // Tests ERB bank creation, comparing against matlab output.
 TEST_F(IntelligibilityEnhancerTest, TestErbCreation) {
   ASSERT_EQ(arraysize(kTestCenterFreqs), enh_->bank_size_);
@@ skipping 29 matching lines @@
   for (size_t i = 0; i < enh_->bank_size_; i++) {
     EXPECT_NEAR(kTestNonZeroVarLambdaTop[i], sols[i], kMaxTestError);
   }
   lambda = -1.f;
   enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, sols.data());
   for (size_t i = 0; i < enh_->bank_size_; i++) {
     EXPECT_NEAR(kTestNonZeroVarLambdaTop[i], sols[i], kMaxTestError);
   }
 }
 
+TEST_F(IntelligibilityEnhancerTest, TestNoiseGainHasExpectedResult) {
+  const int kGainDB = 6;
+  const float kGainFactor = std::pow(10.f, kGainDB / 20.f);
+  const float kTolerance = 0.003f;
+  std::vector<float> noise(kNumNoiseBins);
+  std::vector<float> noise_psd(kNumNoiseBins);
+  std::generate(noise.begin(), noise.end(), float_rand);
+  for (size_t i = 0; i < kNumNoiseBins; ++i) {
+    noise_psd[i] = kGainFactor * kGainFactor * noise[i] * noise[i];
+  }
+  float* clear_cursor = clear_data_.data();
+  for (size_t i = 0; i < kNumFramesToProcess; ++i) {
+    enh_->SetCaptureNoiseEstimate(noise, kGainDB);
+    enh_->ProcessRenderAudio(&clear_cursor, kSampleRate, kNumChannels);
+  }
+  const std::vector<float>& estimated_psd =
+      enh_->noise_power_estimator_.power();
+  for (size_t i = 0; i < kNumNoiseBins; ++i) {
+    EXPECT_LT(std::abs(estimated_psd[i] - noise_psd[i]) / noise_psd[i],
+              kTolerance);
+  }
+}
+
 TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Mono8kHz) {
   const float kOutputReference[] = {-0.001892f, -0.003296f, -0.001953f};
 
   RunBitexactnessTest(AudioProcessing::kSampleRate8kHz, 1, kOutputReference);
 }
 
 TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Mono16kHz) {
   const float kOutputReference[] = {-0.000977f, -0.003296f, -0.002441f};
 
   RunBitexactnessTest(AudioProcessing::kSampleRate16kHz, 1, kOutputReference);
@@ skipping 33 matching lines @@
 }
 
 TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Stereo48kHz) {
   const float kOutputReference[] = {-0.009276f, -0.001601f, -0.008255f,
                                     -0.012975f, -0.015940f, -0.017820f};
 
   RunBitexactnessTest(AudioProcessing::kSampleRate48kHz, 2, kOutputReference);
 }
 
 }  // namespace webrtc