Refactored the comfort noise generation code in the AEC.

webrtc/modules/audio_processing/aec/aec_core.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 500 matching lines @@
 static void GetHighbandGain(const float* lambda, float* nlpGainHband) {
   int i;
 
   *nlpGainHband = 0.0f;
   for (i = freqAvgIc; i < PART_LEN1 - 1; i++) {
     *nlpGainHband += lambda[i];
   }
   *nlpGainHband /= static_cast<float>(PART_LEN1 - 1 - freqAvgIc);
 }
 
-static void ComfortNoise(AecCore* aec,
-                         float efw[2][PART_LEN1],
-                         float comfortNoiseHband[2][PART_LEN1],
-                         const float* noisePow,
-                         const float* lambda) {
-  int i, num;
-  float rand[PART_LEN];
-  float noise, noiseAvg, tmp, tmpAvg;
+static void GenerateComplexNoise(uint32_t* seed, float noise[2][PART_LEN1]) {
+  const float kPi2 = 6.28318530717959f;
   int16_t randW16[PART_LEN];
-  float u[2][PART_LEN1];
+  WebRtcSpl_RandUArray(randW16, PART_LEN, seed);
 
-  const float pi2 = 6.28318530717959f;
+  noise[0][0] = 0;
+  noise[1][0] = 0;
+  for (size_t i = 1; i < PART_LEN1; i++) {
+    float tmp = kPi2 * randW16[i - 1] / 32768.f;
+    noise[0][i] = cosf(tmp);
+    noise[1][i] = -sinf(tmp);
+  }
+  noise[1][PART_LEN] = 0;
+}
 
-  // Generate a uniform random array on [0 1]
-  WebRtcSpl_RandUArray(randW16, PART_LEN, &aec->seed);
-  for (i = 0; i < PART_LEN; i++) {
-    rand[i] = static_cast<float>(randW16[i]) / 32768;
+static void ComfortNoise(bool generate_high_frequency_noise,
+                         uint32_t* seed,
+                         float e_fft[2][PART_LEN1],
+                         float high_frequency_comfort_noise[2][PART_LEN1],
+                         const float* noise_spectrum,
+                         const float* suppressor_gain) {
+  float complex_noise[2][PART_LEN1];
+
+  GenerateComplexNoise(seed, complex_noise);
+
+  // Shape, scale and add comfort noise.
+  for (int i = 1; i < PART_LEN1; ++i) {
+    float noise_scaling =
+        sqrtf(WEBRTC_SPL_MAX(1 - suppressor_gain[i] * suppressor_gain[i], 0)) *
+        sqrtf(noise_spectrum[i]);
+    e_fft[0][i] += noise_scaling * complex_noise[0][i];
+    e_fft[1][i] += noise_scaling * complex_noise[1][i];
   }
 
-  // Reject LF noise
-  u[0][0] = 0;
-  u[1][0] = 0;
-  for (i = 1; i < PART_LEN1; i++) {
-    tmp = pi2 * rand[i - 1];
+  // Form comfort noise for higher frequencies.
+  if (generate_high_frequency_noise) {
+    // Compute average noise power and nlp gain over the second half of freq
+    // spectrum (i.e., 4->8khz).
+    int start_avg_band = PART_LEN1 / 2;
+    float upper_bands_noise_power = 0.f;
+    float upper_bands_suppressor_gain = 0.f;
+    for (int i = start_avg_band; i < PART_LEN1; ++i) {
+      upper_bands_noise_power += sqrtf(noise_spectrum[i]);
+      upper_bands_suppressor_gain +=
+          sqrtf(WEBRTC_SPL_MAX(1 - suppressor_gain[i] * suppressor_gain[i], 0));
+    }
+    upper_bands_noise_power /= (PART_LEN1 - start_avg_band);
+    upper_bands_suppressor_gain /= (PART_LEN1 - start_avg_band);
 
-    noise = sqrtf(noisePow[i]);
-    u[0][i] = noise * cosf(tmp);
-    u[1][i] = -noise * sinf(tmp);
-  }
-  u[1][PART_LEN] = 0;
-
-  for (i = 0; i < PART_LEN1; i++) {
-    // This is the proper weighting to match the background noise power
-    tmp = sqrtf(WEBRTC_SPL_MAX(1 - lambda[i] * lambda[i], 0));
-    // tmp = 1 - lambda[i];
-    efw[0][i] += tmp * u[0][i];
-    efw[1][i] += tmp * u[1][i];
-  }
-
-  // For H band comfort noise
-  // TODO(peah): don't compute noise and "tmp" twice. Use the previous results.
-  noiseAvg = 0.0;
-  tmpAvg = 0.0;
-  num = 0;
-  if (aec->num_bands > 1) {
-    // average noise scale
-    // average over second half of freq spectrum (i.e., 4->8khz)
-    // TODO(peah): we shouldn't need num. We know how many elements we're
-    // summing.
-    for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
-      num++;
-      noiseAvg += sqrtf(noisePow[i]);
+    // Shape, scale and add comfort noise.
+    float noise_scaling = upper_bands_suppressor_gain * upper_bands_noise_power;
+    high_frequency_comfort_noise[0][0] = 0;
+    high_frequency_comfort_noise[1][0] = 0;
+    for (int i = 1; i < PART_LEN1; ++i) {
+      high_frequency_comfort_noise[0][i] = noise_scaling * complex_noise[0][i];
+      high_frequency_comfort_noise[1][i] = noise_scaling * complex_noise[1][i];
     }
-    noiseAvg /= static_cast<float>(num);
-
-    // average nlp scale
-    // average over second half of freq spectrum (i.e., 4->8khz)
-    // TODO(peah): we shouldn't need num. We know how many elements
-    // we're summing.
-    num = 0;
-    for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
-      num++;
-      tmpAvg += sqrtf(WEBRTC_SPL_MAX(1 - lambda[i] * lambda[i], 0));
-    }
-    tmpAvg /= static_cast<float>(num);
-
-    // Use average noise for H band
-    // TODO(peah): we should probably have a new random vector here.
-    // Reject LF noise
-    u[0][0] = 0;
-    u[1][0] = 0;
-    for (i = 1; i < PART_LEN1; i++) {
-      tmp = pi2 * rand[i - 1];
-
-      // Use average noise for H band
-      u[0][i] = noiseAvg * static_cast<float>(cos(tmp));
-      u[1][i] = -noiseAvg * static_cast<float>(sin(tmp));
-    }
-    u[1][PART_LEN] = 0;
-
-    for (i = 0; i < PART_LEN1; i++) {
-      // Use average NLP weight for H band
-      comfortNoiseHband[0][i] = tmpAvg * u[0][i];
-      comfortNoiseHband[1][i] = tmpAvg * u[1][i];
-    }
+    high_frequency_comfort_noise[1][PART_LEN] = 0;
   } else {
-    memset(comfortNoiseHband, 0,
-           2 * PART_LEN1 * sizeof(comfortNoiseHband[0][0]));
+    memset(high_frequency_comfort_noise, 0,
+           2 * PART_LEN1 * sizeof(high_frequency_comfort_noise[0][0]));
   }
 }
 
 static void InitLevel(PowerLevel* level) {
   const float kBigFloat = 1E17f;
   level->averagelevel.Reset();
   level->framelevel.Reset();
   level->minlevel = kBigFloat;
 }
 
@@ skipping 549 matching lines @@
   // diverged.
   if (aec->divergeState) {
     memcpy(efw, dfw, sizeof(efw[0][0]) * 2 * PART_LEN1);
   }
 
   FormSuppressionGain(aec, cohde, cohxd, hNl);
 
   WebRtcAec_Suppress(hNl, efw);
 
   // Add comfort noise.
-  ComfortNoise(aec, efw, comfortNoiseHband, aec->noisePow, hNl);
+  ComfortNoise(aec->num_bands > 1, &aec->seed, efw, comfortNoiseHband,
+               aec->noisePow, hNl);
 
   // Inverse error fft.
   ScaledInverseFft(efw, fft, 2.0f, 1);
 
   // Overlap and add to obtain output.
   for (i = 0; i < PART_LEN; i++) {
     output[i] = (fft[i] * WebRtcAec_sqrtHanning[i] +
                  aec->outBuf[i] * WebRtcAec_sqrtHanning[PART_LEN - i]);
 
     // Saturate output to keep it in the allowed range.
@@ skipping 778 matching lines @@
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }
 }  // namespace webrtc