1 files changed, 107 insertions, 113 deletions

diff --git a/webrtc/modules/audio_processing/noise_suppression_impl.cc b/webrtc/modules/audio_processing/noise_suppression_impl.cc
index 65ec3c445e..de7e856676 100644
--- a/webrtc/modules/audio_processing/noise_suppression_impl.cc
+++ b/webrtc/modules/audio_processing/noise_suppression_impl.cc
@@ -10,172 +10,166 @@
 
 #include "webrtc/modules/audio_processing/noise_suppression_impl.h"
 
-#include <assert.h>
-
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #if defined(WEBRTC_NS_FLOAT)
-#include "webrtc/modules/audio_processing/ns/include/noise_suppression.h"
+#include "webrtc/modules/audio_processing/ns/noise_suppression.h"
+#define NS_CREATE WebRtcNs_Create
+#define NS_FREE WebRtcNs_Free
+#define NS_INIT WebRtcNs_Init
+#define NS_SET_POLICY WebRtcNs_set_policy
+typedef NsHandle NsState;
 #elif defined(WEBRTC_NS_FIXED)
-#include "webrtc/modules/audio_processing/ns/include/noise_suppression_x.h"
+#include "webrtc/modules/audio_processing/ns/noise_suppression_x.h"
+#define NS_CREATE WebRtcNsx_Create
+#define NS_FREE WebRtcNsx_Free
+#define NS_INIT WebRtcNsx_Init
+#define NS_SET_POLICY WebRtcNsx_set_policy
+typedef NsxHandle NsState;
 #endif
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
-
 
 namespace webrtc {
-
-#if defined(WEBRTC_NS_FLOAT)
-typedef NsHandle Handle;
-#elif defined(WEBRTC_NS_FIXED)
-typedef NsxHandle Handle;
-#endif
-
-namespace {
-int MapSetting(NoiseSuppression::Level level) {
-  switch (level) {
-    case NoiseSuppression::kLow:
-      return 0;
-    case NoiseSuppression::kModerate:
-      return 1;
-    case NoiseSuppression::kHigh:
-      return 2;
-    case NoiseSuppression::kVeryHigh:
-      return 3;
+class NoiseSuppressionImpl::Suppressor {
+ public:
+  explicit Suppressor(int sample_rate_hz) {
+    state_ = NS_CREATE();
+    RTC_CHECK(state_);
+    int error = NS_INIT(state_, sample_rate_hz);
+    RTC_DCHECK_EQ(0, error);
+  }
+  ~Suppressor() {
+    NS_FREE(state_);
   }
-  assert(false);
-  return -1;
+  NsState* state() { return state_; }
+ private:
+  NsState* state_ = nullptr;
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Suppressor);
+};
+
+NoiseSuppressionImpl::NoiseSuppressionImpl(rtc::CriticalSection* crit)
+    : crit_(crit) {
+  RTC_DCHECK(crit);
 }
-}  // namespace
-
-NoiseSuppressionImpl::NoiseSuppressionImpl(const AudioProcessing* apm,
-                                           CriticalSectionWrapper* crit)
-  : ProcessingComponent(),
-    apm_(apm),
-    crit_(crit),
-    level_(kModerate) {}
 
 NoiseSuppressionImpl::~NoiseSuppressionImpl() {}
 
-int NoiseSuppressionImpl::AnalyzeCaptureAudio(AudioBuffer* audio) {
-#if defined(WEBRTC_NS_FLOAT)
-  if (!is_component_enabled()) {
-    return apm_->kNoError;
+void NoiseSuppressionImpl::Initialize(size_t channels, int sample_rate_hz) {
+  rtc::CritScope cs(crit_);
+  channels_ = channels;
+  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));
+    }
   }
-  assert(audio->num_frames_per_band() <= 160);
-  assert(audio->num_channels() == num_handles());
+  suppressors_.swap(new_suppressors);
+  set_level(level_);
+}
 
-  for (int i = 0; i < num_handles(); ++i) {
-    Handle* my_handle = static_cast<Handle*>(handle(i));
+void NoiseSuppressionImpl::AnalyzeCaptureAudio(AudioBuffer* audio) {
+  RTC_DCHECK(audio);
+#if defined(WEBRTC_NS_FLOAT)
+  rtc::CritScope cs(crit_);
+  if (!enabled_) {
+    return;
+  }
 
-    WebRtcNs_Analyze(my_handle, audio->split_bands_const_f(i)[kBand0To8kHz]);
+  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]);
   }
 #endif
-  return apm_->kNoError;
 }
 
-int NoiseSuppressionImpl::ProcessCaptureAudio(AudioBuffer* audio) {
-  if (!is_component_enabled()) {
-    return apm_->kNoError;
+void NoiseSuppressionImpl::ProcessCaptureAudio(AudioBuffer* audio) {
+  RTC_DCHECK(audio);
+  rtc::CritScope cs(crit_);
+  if (!enabled_) {
+    return;
   }
-  assert(audio->num_frames_per_band() <= 160);
-  assert(audio->num_channels() == num_handles());
 
-  for (int i = 0; i < num_handles(); ++i) {
-    Handle* my_handle = static_cast<Handle*>(handle(i));
+  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(my_handle,
+    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(my_handle,
+    WebRtcNsx_Process(suppressors_[i]->state(),
                       audio->split_bands_const(i),
                       audio->num_bands(),
                       audio->split_bands(i));
 #endif
   }
-  return apm_->kNoError;
 }
 
 int NoiseSuppressionImpl::Enable(bool enable) {
-  CriticalSectionScoped crit_scoped(crit_);
-  return EnableComponent(enable);
+  rtc::CritScope cs(crit_);
+  if (enabled_ != enable) {
+    enabled_ = enable;
+    Initialize(channels_, sample_rate_hz_);
+  }
+  return AudioProcessing::kNoError;
 }
 
 bool NoiseSuppressionImpl::is_enabled() const {
-  return is_component_enabled();
+  rtc::CritScope cs(crit_);
+  return enabled_;
 }
 
 int NoiseSuppressionImpl::set_level(Level level) {
-  CriticalSectionScoped crit_scoped(crit_);
-  if (MapSetting(level) == -1) {
-    return apm_->kBadParameterError;
+  int policy = 1;
+  switch (level) {
+    case NoiseSuppression::kLow:
+      policy = 0;
+      break;
+    case NoiseSuppression::kModerate:
+      policy = 1;
+      break;
+    case NoiseSuppression::kHigh:
+      policy = 2;
+      break;
+    case NoiseSuppression::kVeryHigh:
+      policy = 3;
+      break;
+    default:
+      RTC_NOTREACHED();
   }
-
+  rtc::CritScope cs(crit_);
   level_ = level;
-  return Configure();
+  for (auto& suppressor : suppressors_) {
+    int error = NS_SET_POLICY(suppressor->state(), policy);
+    RTC_DCHECK_EQ(0, error);
+  }
+  return AudioProcessing::kNoError;
 }
 
 NoiseSuppression::Level NoiseSuppressionImpl::level() const {
+  rtc::CritScope cs(crit_);
   return level_;
 }
 
 float NoiseSuppressionImpl::speech_probability() const {
+  rtc::CritScope cs(crit_);
 #if defined(WEBRTC_NS_FLOAT)
   float probability_average = 0.0f;
-  for (int i = 0; i < num_handles(); i++) {
-    Handle* my_handle = static_cast<Handle*>(handle(i));
-    probability_average += WebRtcNs_prior_speech_probability(my_handle);
+  for (auto& suppressor : suppressors_) {
+    probability_average +=
+        WebRtcNs_prior_speech_probability(suppressor->state());
   }
-  return probability_average / num_handles();
+  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 apm_->kUnsupportedFunctionError;
+  return AudioProcessing::kUnsupportedFunctionError;
 #endif
 }
-
-void* NoiseSuppressionImpl::CreateHandle() const {
-#if defined(WEBRTC_NS_FLOAT)
-  return WebRtcNs_Create();
-#elif defined(WEBRTC_NS_FIXED)
-  return WebRtcNsx_Create();
-#endif
-}
-
-void NoiseSuppressionImpl::DestroyHandle(void* handle) const {
-#if defined(WEBRTC_NS_FLOAT)
-  WebRtcNs_Free(static_cast<Handle*>(handle));
-#elif defined(WEBRTC_NS_FIXED)
-  WebRtcNsx_Free(static_cast<Handle*>(handle));
-#endif
-}
-
-int NoiseSuppressionImpl::InitializeHandle(void* handle) const {
-#if defined(WEBRTC_NS_FLOAT)
-  return WebRtcNs_Init(static_cast<Handle*>(handle),
-                       apm_->proc_sample_rate_hz());
-#elif defined(WEBRTC_NS_FIXED)
-  return WebRtcNsx_Init(static_cast<Handle*>(handle),
-                        apm_->proc_sample_rate_hz());
-#endif
-}
-
-int NoiseSuppressionImpl::ConfigureHandle(void* handle) const {
-#if defined(WEBRTC_NS_FLOAT)
-  return WebRtcNs_set_policy(static_cast<Handle*>(handle),
-                             MapSetting(level_));
-#elif defined(WEBRTC_NS_FIXED)
-  return WebRtcNsx_set_policy(static_cast<Handle*>(handle),
-                              MapSetting(level_));
-#endif
-}
-
-int NoiseSuppressionImpl::num_handles_required() const {
-  return apm_->num_output_channels();
-}
-
-int NoiseSuppressionImpl::GetHandleError(void* handle) const {
-  // The NS has no get_error() function.
-  assert(handle != NULL);
-  return apm_->kUnspecifiedError;
-}
 }  // namespace webrtc