Using the NS noise estimate for the IE

webrtc/modules/audio_processing/intelligibility/test/intelligibility_proc.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
 //
 //  Command line tool for speech intelligibility enhancement. Provides for
 //  running and testing intelligibility_enhancer as an independent process.
 //  Use --help for options.
 //
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <string>
 
 #include "gflags/gflags.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/common_audio/real_fourier.h"
 #include "webrtc/common_audio/wav_file.h"
+#include "webrtc/modules/audio_processing/audio_buffer.h"
+#include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h"
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h"
+#include "webrtc/modules/audio_processing/noise_suppression_impl.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using std::complex;
 using webrtc::intelligibility::VarianceArray;
 
 namespace webrtc {
 namespace {
 
 bool ValidateClearWindow(const char* flagname, int32_t value) {
@@ skipping 68 matching lines @@
 
   // Run intelligibility enhancement.
   IntelligibilityEnhancer::Config config;
   config.sample_rate_hz = FLAGS_sample_rate;
   config.var_type = static_cast<VarianceArray::StepType>(FLAGS_clear_type);
   config.var_decay_rate = static_cast<float>(FLAGS_clear_alpha);
   config.var_window_size = static_cast<size_t>(FLAGS_clear_window);
   config.analysis_rate = FLAGS_ana_rate;
   config.gain_change_limit = FLAGS_gain_limit;
   IntelligibilityEnhancer enh(config);
+  rtc::CriticalSection crit;
+  NoiseSuppressionImpl ns(&crit);
+  ns.Initialize(kNumChannels, FLAGS_sample_rate);
+  ns.Enable(true);
+
+  AudioBuffer capture_audio(fragment_size,
+                            kNumChannels,
+                            fragment_size,
+                            kNumChannels,
+                            fragment_size);
+  StreamConfig stream_config(FLAGS_sample_rate, kNumChannels);
 
   // Slice the input into smaller chunks, as the APM would do, and feed them
   // through the enhancer.
   float* clear_cursor = &in_fpcm[0];
   float* noise_cursor = &noise_fpcm[0];
 
   for (size_t i = 0; i < samples; i += fragment_size) {
-    enh.AnalyzeCaptureAudio(&noise_cursor, FLAGS_sample_rate, kNumChannels);
+    capture_audio.CopyFrom(&noise_cursor, stream_config);
+    ns.AnalyzeCaptureAudio(&capture_audio);
+    ns.ProcessCaptureAudio(&capture_audio);
+    enh.SetCaptureNoiseEstimate(ns.noise_estimate());
     enh.ProcessRenderAudio(&clear_cursor, FLAGS_sample_rate, kNumChannels);
     clear_cursor += fragment_size;
     noise_cursor += fragment_size;
   }
 
   if (FLAGS_out_file.compare("-") == 0) {
     const std::string temp_out_filename =
         test::TempFilename(test::WorkingDir(), "temp_wav_file");
     {
       WavWriter out_file(temp_out_filename, FLAGS_sample_rate, kNumChannels);
       out_file.WriteSamples(&in_fpcm[0], samples);
     }
     system(("aplay " + temp_out_filename).c_str());
     system(("rm " + temp_out_filename).c_str());
   } else {
     WavWriter out_file(FLAGS_out_file, FLAGS_sample_rate, kNumChannels);
     out_file.WriteSamples(&in_fpcm[0], samples);
   }
 }
 
 }  // namespace
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   webrtc::void_main(argc, argv);
   return 0;
 }