Convert IntelligibilityEnhancer to multi-threaded mode

webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.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.
  */
 
@@ skipping 43 matching lines @@
                    float* result) {
   for (size_t i = 0; i < filter_bank.size(); ++i) {
     RTC_DCHECK_GT(filter_bank[i].size(), 0u);
     result[i] = DotProduct(filter_bank[i].data(), pow, filter_bank[i].size());
   }
 }
 
 }  // namespace
 
 IntelligibilityEnhancer::IntelligibilityEnhancer(int sample_rate_hz,
-                                                 size_t num_render_channels)
+                                                 size_t num_render_channels,
+                                                 size_t num_noise_bins)
     : freqs_(RealFourier::ComplexLength(
           RealFourier::FftOrder(sample_rate_hz * kWindowSizeMs / 1000))),
+      num_noise_bins_(num_noise_bins),
       chunk_length_(static_cast<size_t>(sample_rate_hz * kChunkSizeMs / 1000)),
       bank_size_(GetBankSize(sample_rate_hz, kErbResolution)),
       sample_rate_hz_(sample_rate_hz),
       num_render_channels_(num_render_channels),
       clear_power_estimator_(freqs_, kDecayRate),
-      noise_power_estimator_(
-          new intelligibility::PowerEstimator<float>(freqs_, kDecayRate)),
+      noise_power_estimator_(num_noise_bins, kDecayRate),
       filtered_clear_pow_(bank_size_, 0.f),
-      filtered_noise_pow_(bank_size_, 0.f),
+      filtered_noise_pow_(num_noise_bins, 0.f),
       center_freqs_(bank_size_),
+      capture_filter_bank_(CreateErbBank(num_noise_bins)),
       render_filter_bank_(CreateErbBank(freqs_)),
       gains_eq_(bank_size_),
       gain_applier_(freqs_, kMaxRelativeGainChange),
       audio_s16_(chunk_length_),
       chunks_since_voice_(kSpeechOffsetDelay),
-      is_speech_(false) {
+      is_speech_(false),
+      noise_estimation_buffer_(num_noise_bins),
+      noise_estimation_queue_(kMaxNumNoiseEstimatesToBuffer,
+                              std::vector<float>(num_noise_bins),
+                              RenderQueueItemVerifier<float>(num_noise_bins)) {
   RTC_DCHECK_LE(kRho, 1.f);
 
   const size_t erb_index = static_cast<size_t>(
       ceilf(11.17f * logf((kClipFreqKhz + 0.312f) / (kClipFreqKhz + 14.6575f)) +
             43.f));
   start_freq_ = std::max(static_cast<size_t>(1), erb_index * kErbResolution);
 
   size_t window_size = static_cast<size_t>(1 << RealFourier::FftOrder(freqs_));
   std::vector<float> kbd_window(window_size);
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, window_size,
                                        kbd_window.data());
   render_mangler_.reset(new LappedTransform(
       num_render_channels_, num_render_channels_, chunk_length_,
       kbd_window.data(), window_size, window_size / 2, this));
 }
 
 void IntelligibilityEnhancer::SetCaptureNoiseEstimate(
     std::vector<float> noise) {
-  if (capture_filter_bank_.size() != bank_size_ ||
-      capture_filter_bank_[0].size() != noise.size()) {
-    capture_filter_bank_ = CreateErbBank(noise.size());
-    noise_power_estimator_.reset(
-        new intelligibility::PowerEstimator<float>(noise.size(), kDecayRate));
-  }
-  noise_power_estimator_->Step(noise.data());
+  RTC_DCHECK_EQ(noise.size(), num_noise_bins_);
+  // Disregarding return value since buffer overflow is acceptable, because it
+  // is not critical to get each noise estimate.
+  if (noise_estimation_queue_.Insert(&noise)) {
+  };

[tommi (sloooow) - chröme, 2016/03/10 21:59:12]

nit: remove the if() and then you can leave in the semicolon ;)

[aluebs-webrtc, 2016/03/11 09:36:48]

That is a way of making all compilers happy and not complain about the
warn_unused_result warning (casting to void didn't do the trick for android) and
was tried to be explained in the comment above.

 }
 
 void IntelligibilityEnhancer::ProcessRenderAudio(float* const* audio,
                                                  int sample_rate_hz,
                                                  size_t num_channels) {
   RTC_CHECK_EQ(sample_rate_hz_, sample_rate_hz);
   RTC_CHECK_EQ(num_render_channels_, num_channels);
+  while (noise_estimation_queue_.Remove(&noise_estimation_buffer_)) {
+    noise_power_estimator_.Step(noise_estimation_buffer_.data());
+  }
   is_speech_ = IsSpeech(audio[0]);
   render_mangler_->ProcessChunk(audio, audio);
 }
 
 void IntelligibilityEnhancer::ProcessAudioBlock(
     const std::complex<float>* const* in_block,
     size_t in_channels,
     size_t frames,
     size_t /* out_channels */,
     std::complex<float>* const* out_block) {
   RTC_DCHECK_EQ(freqs_, frames);
   if (is_speech_) {
     clear_power_estimator_.Step(in_block[0]);
   }
   const std::vector<float>& clear_power = clear_power_estimator_.power();
-  const std::vector<float>& noise_power = noise_power_estimator_->power();
+  const std::vector<float>& noise_power = noise_power_estimator_.power();
   MapToErbBands(clear_power.data(), render_filter_bank_,
                 filtered_clear_pow_.data());
   MapToErbBands(noise_power.data(), capture_filter_bank_,
                 filtered_noise_pow_.data());
   SolveForGainsGivenLambda(kLambdaTop, start_freq_, gains_eq_.data());
   const float power_target =
       std::accumulate(clear_power.data(), clear_power.data() + freqs_, 0.f);
   const float power_top =
       DotProduct(gains_eq_.data(), filtered_clear_pow_.data(), bank_size_);
   SolveForGainsGivenLambda(kLambdaBot, start_freq_, gains_eq_.data());
@@ skipping 158 matching lines @@
   vad_.ProcessChunk(audio_s16_.data(), chunk_length_, sample_rate_hz_);
   if (vad_.last_voice_probability() > kVoiceProbabilityThreshold) {
     chunks_since_voice_ = 0;
   } else if (chunks_since_voice_ < kSpeechOffsetDelay) {
     ++chunks_since_voice_;
   }
   return chunks_since_voice_ < kSpeechOffsetDelay;
 }
 
 }  // namespace webrtc