Retyped the frequency estimate of the comfort noise for the higher band to harmonize the AEC code(#4

webrtc/modules/audio_processing/aec/aec_core.c

 /*
  *  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 423 matching lines @@
 
   *nlpGainHband = (float)0.0;
   for (i = freqAvgIc; i < PART_LEN1 - 1; i++) {
     *nlpGainHband += lambda[i];
   }
   *nlpGainHband /= (float)(PART_LEN1 - 1 - freqAvgIc);
 }
 
 static void ComfortNoise(AecCore* aec,
                          float efw[2][PART_LEN1],
-                         complex_t* comfortNoiseHband,
+                         float comfortNoiseHband[2][PART_LEN1],
                          const float* noisePow,
                          const float* lambda) {
   int i, num;
   float rand[PART_LEN];
   float noise, noiseAvg, tmp, tmpAvg;
   int16_t randW16[PART_LEN];
-  complex_t u[PART_LEN1];
+  float u[2][PART_LEN1];
 
   const float pi2 = 6.28318530717959f;
 
   // Generate a uniform random array on [0 1]
   WebRtcSpl_RandUArray(randW16, PART_LEN, &aec->seed);
   for (i = 0; i < PART_LEN; i++) {
     rand[i] = ((float)randW16[i]) / 32768;
   }
 
   // Reject LF noise
   u[0][0] = 0;
-  u[0][1] = 0;
+  u[1][0] = 0;
   for (i = 1; i < PART_LEN1; i++) {
     tmp = pi2 * rand[i - 1];
 
     noise = sqrtf(noisePow[i]);
-    u[i][0] = noise * cosf(tmp);
-    u[i][1] = -noise * sinf(tmp);
+    u[0][i] = noise * cosf(tmp);
+    u[1][i] = -noise * sinf(tmp);
   }
-  u[PART_LEN][1] = 0;
+  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[i][0];
-    efw[1][i] += tmp * u[i][1];
+    efw[0][i] += tmp * u[0][i];
+    efw[1][i] += tmp * u[1][i];
   }
 
   // For H band comfort noise
   // TODO: don't compute noise and "tmp" twice. Use the previous results.
   noiseAvg = 0.0;
   tmpAvg = 0.0;
   num = 0;
   if (aec->num_bands > 1 && flagHbandCn == 1) {
 
     // average noise scale
@@ skipping 12 matching lines @@
     for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
       num++;
       tmpAvg += sqrtf(WEBRTC_SPL_MAX(1 - lambda[i] * lambda[i], 0));
     }
     tmpAvg /= (float)num;
 
     // Use average noise for H band
     // TODO: we should probably have a new random vector here.
     // Reject LF noise
     u[0][0] = 0;
-    u[0][1] = 0;
+    u[1][0] = 0;
     for (i = 1; i < PART_LEN1; i++) {
       tmp = pi2 * rand[i - 1];
 
       // Use average noise for H band
-      u[i][0] = noiseAvg * (float)cos(tmp);
-      u[i][1] = -noiseAvg * (float)sin(tmp);
+      u[0][i] = noiseAvg * (float)cos(tmp);
+      u[1][i] = -noiseAvg * (float)sin(tmp);
     }
-    u[PART_LEN][1] = 0;
+    u[1][PART_LEN] = 0;
 
     for (i = 0; i < PART_LEN1; i++) {
       // Use average NLP weight for H band
-      comfortNoiseHband[i][0] = tmpAvg * u[i][0];
-      comfortNoiseHband[i][1] = tmpAvg * u[i][1];
+      comfortNoiseHband[0][i] = tmpAvg * u[0][i];
+      comfortNoiseHband[1][i] = tmpAvg * u[1][i];
     }
   }
+  else {

[minyue-webrtc, 2015/12/04 09:49:43]

move 527 to 526

[peah-webrtc, 2015/12/04 23:02:48]

Done.

+    memset(comfortNoiseHband, 0,
+           2 * PART_LEN1 * sizeof(comfortNoiseHband[0][0]));

[minyue-webrtc, 2015/12/04 09:49:44]

I prefer use sizeof(comfortNoiseHband), since it is well defined.

[peah-webrtc, 2015/12/04 23:02:48]

Me too, but it does not work for multidimensional arrays when they are passed as
method arguments. The compiler complains about that construct.

[minyue-webrtc, 2015/12/08 12:33:01]

Acknowledged.

+  }
 }
 
 static void InitLevel(PowerLevel* level) {
   const float kBigFloat = 1E17f;
 
   level->averagelevel = 0;
   level->framelevel = 0;
   level->minlevel = kBigFloat;
   level->frsum = 0;
   level->sfrsum = 0;
@@ skipping 466 matching lines @@
 }
 
 
 static void EchoSuppression(AecCore* aec,
                             float* echo_subtractor_output,
                             float* output,
                             float* const* outputH) {
   float efw[2][PART_LEN1];
   float xfw[2][PART_LEN1];
   float dfw[2][PART_LEN1];
-  complex_t comfortNoiseHband[PART_LEN1];
+  float comfortNoiseHband[2][PART_LEN1];
   float fft[PART_LEN2];
   float scale, dtmp;
   float nlpGainHband;
   int i;
   size_t j;
 
   // Coherence and non-linear filter
   float cohde[PART_LEN1], cohxd[PART_LEN1];
   float hNlDeAvg, hNlXdAvg;
   float hNl[PART_LEN1];
@@ skipping 148 matching lines @@
   // Smooth the overdrive.
   if (aec->overDrive < aec->overDriveSm) {
     aec->overDriveSm = 0.99f * aec->overDriveSm + 0.01f * aec->overDrive;
   } else {
     aec->overDriveSm = 0.9f * aec->overDriveSm + 0.1f * aec->overDrive;
   }
 
   WebRtcAec_OverdriveAndSuppress(aec, hNl, hNlFb, efw);
 
   // Add comfort noise.
-  memset(comfortNoiseHband, 0, sizeof(comfortNoiseHband));
   WebRtcAec_ComfortNoise(aec, efw, comfortNoiseHband, aec->noisePow, hNl);
 
   // TODO(bjornv): Investigate how to take the windowing below into account if
   // needed.
   if (aec->metricsMode == 1) {
     // Note that we have a scaling by two in the time domain |eBuf|.
     // In addition the time domain signal is windowed before transformation,
     // losing half the energy on the average. We take care of the first
     // scaling only in UpdateMetrics().
     UpdateLevel(&aec->nlpoutlevel, efw);
@@ skipping 26 matching lines @@
   if (aec->num_bands > 1) {
 
     // H band gain
     // average nlp over low band: average over second half of freq spectrum
     // (4->8khz)
     GetHighbandGain(hNl, &nlpGainHband);
 
     // Inverse comfort_noise
     if (flagHbandCn == 1) {
       fft[0] = comfortNoiseHband[0][0];
-      fft[1] = comfortNoiseHband[PART_LEN][0];
+      fft[1] = comfortNoiseHband[0][PART_LEN];
       for (i = 1; i < PART_LEN; i++) {
-        fft[2 * i] = comfortNoiseHband[i][0];
-        fft[2 * i + 1] = comfortNoiseHband[i][1];
+        fft[2 * i] = comfortNoiseHband[0][i];
+        fft[2 * i + 1] = comfortNoiseHband[1][i];
       }
       aec_rdft_inverse_128(fft);
       scale = 2.0f / PART_LEN2;
     }
 
     // compute gain factor
     for (j = 0; j < aec->num_bands - 1; ++j) {
       for (i = 0; i < PART_LEN; i++) {
         dtmp = aec->dBufH[j][i];
         dtmp = dtmp * nlpGainHband;  // for variable gain
@@ skipping 739 matching lines @@
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
 int WebRtcAec_system_delay(AecCore* self) { return self->system_delay; }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }