Surface the noise estimate of the NS to be used by other components

webrtc/modules/audio_processing/noise_suppression_impl.cc

 /*
  *  Copyright (c) 2012 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 47 matching lines @@
   sample_rate_hz_ = sample_rate_hz;
   std::vector<rtc::scoped_ptr<Suppressor>> new_suppressors;
   if (enabled_) {
     new_suppressors.resize(channels);
     for (size_t i = 0; i < channels; i++) {
       new_suppressors[i].reset(new Suppressor(sample_rate_hz));
     }
   }
   suppressors_.swap(new_suppressors);
   set_level(level_);
+  noise_estimate_updated_ = false;
 }
 
 void NoiseSuppressionImpl::AnalyzeCaptureAudio(AudioBuffer* audio) {
   RTC_DCHECK(audio);
 #if defined(WEBRTC_NS_FLOAT)
   rtc::CritScope cs(crit_);
   if (!enabled_) {
     return;
   }
 
   RTC_DCHECK_GE(160u, audio->num_frames_per_band());
   RTC_DCHECK_EQ(suppressors_.size(), audio->num_channels());
   for (size_t i = 0; i < suppressors_.size(); i++) {
     WebRtcNs_Analyze(suppressors_[i]->state(),
                      audio->split_bands_const_f(i)[kBand0To8kHz]);
   }
+  noise_estimate_updated_ = true;
 #endif
 }
 
 void NoiseSuppressionImpl::ProcessCaptureAudio(AudioBuffer* audio) {
   RTC_DCHECK(audio);
   rtc::CritScope cs(crit_);
   if (!enabled_) {
     return;
   }
 
   RTC_DCHECK_GE(160u, audio->num_frames_per_band());
   RTC_DCHECK_EQ(suppressors_.size(), audio->num_channels());
   for (size_t i = 0; i < suppressors_.size(); i++) {
 #if defined(WEBRTC_NS_FLOAT)
     WebRtcNs_Process(suppressors_[i]->state(),
                      audio->split_bands_const_f(i),
                      audio->num_bands(),
                      audio->split_bands_f(i));
 #elif defined(WEBRTC_NS_FIXED)
     WebRtcNsx_Process(suppressors_[i]->state(),
                       audio->split_bands_const(i),
                       audio->num_bands(),
                       audio->split_bands(i));
+    noise_estimate_updated_ = true;
 #endif
   }
 }
 
 int NoiseSuppressionImpl::Enable(bool enable) {
   rtc::CritScope cs(crit_);
   if (enabled_ != enable) {
     enabled_ = enable;
     Initialize(channels_, sample_rate_hz_);
   }
@@ skipping 48 matching lines @@
   if (!suppressors_.empty()) {
     probability_average /= suppressors_.size();
   }
   return probability_average;
 #elif defined(WEBRTC_NS_FIXED)
   // TODO(peah): Returning error code as a float! Remove this.
   // Currently not available for the fixed point implementation.
   return AudioProcessing::kUnsupportedFunctionError;
 #endif
 }
+
+const std::vector<float>& NoiseSuppressionImpl::noise_estimate() {
+  rtc::CritScope cs(crit_);
+  if (noise_estimate_updated_) {
+#if defined(WEBRTC_NS_FLOAT)
+    noise_estimate_.assign(WebRtcNs_num_freq(), 0.f);
+    for (auto& suppressor : suppressors_) {
+      float* noise = WebRtcNs_noise_estimate(suppressor->state());
+      for (size_t i = 0; i < noise_estimate_.size(); ++i) {
+        noise_estimate_[i] += noise[i] / suppressors_.size();
+      }
+    }
+#elif defined(WEBRTC_NS_FIXED)
+    noise_estimate_.assign(WebRtcNsx_num_freq(), 0.f);
+    for (auto& suppressor : suppressors_) {
+      uint32_t* noise = WebRtcNsx_noise_estimate(suppressor->state());
+      for (size_t i = 0; i < noise_estimate_.size(); ++i) {
+        noise_estimate_[i] +=
+            static_cast<float>(noise[i] >> 17) / suppressors_.size();

[turaj, 2016/02/05 01:47:58]

Is nois[] is Q17? maybe a comment helps. And if it is in Q17 by shifting >> 17
we lose precision, I don't know how important it is, perhaps not much, but just
to be fair we can do the division in float.

[aluebs-webrtc, 2016/02/06 00:12:27]

It is an unsigned 32-bit integer, and we want to get it to the level of a signed
16-bit integer, so it needs 17 shifts. I thought about making the division in
float to not lose precision, but I thought it was not going to affect and this
was easier to reed. But I guess you are right. Added comment and did division in
float.

+      }
+    }
+#endif
+    noise_estimate_updated_ = false;
+  }
+  return noise_estimate_;
+}
+
 }  // namespace webrtc