Clang format changes

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 16 matching lines @@
 #include "webrtc/common_audio/ring_buffer.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/aec/aec_common.h"
 #include "webrtc/modules/audio_processing/aec/aec_core_internal.h"
 #include "webrtc/modules/audio_processing/aec/aec_rdft.h"
 #include "webrtc/modules/audio_processing/logging/aec_logging.h"
 #include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 #include "webrtc/typedefs.h"
 
-
 // Buffer size (samples)
 static const size_t kBufSizePartitions = 250;  // 1 second of audio in 16 kHz.
 
 // Metrics
 static const int subCountLen = 4;
 static const int countLen = 50;
 static const int kDelayMetricsAggregationWindow = 1250;  // 5 seconds at 16 kHz.
 
 // Quantities to control H band scaling for SWB input
 static const float cnScaleHband =
@@ skipping 65 matching lines @@
 
 // Two sets of parameters, one for the extended filter mode.
 static const float kExtendedMinOverDrive[3] = {3.0f, 6.0f, 15.0f};
 static const float kNormalMinOverDrive[3] = {1.0f, 2.0f, 5.0f};
 const float WebRtcAec_kExtendedSmoothingCoefficients[2][2] = {{0.9f, 0.1f},
                                                               {0.92f, 0.08f}};
 const float WebRtcAec_kNormalSmoothingCoefficients[2][2] = {{0.9f, 0.1f},
                                                             {0.93f, 0.07f}};
 
 // Number of partitions forming the NLP's "preferred" bands.
-enum {
-  kPrefBandSize = 24
-};
+enum { kPrefBandSize = 24 };
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
 extern int webrtc_aec_instance_count;
 #endif
 
 WebRtcAecFilterFar WebRtcAec_FilterFar;
 WebRtcAecScaleErrorSignal WebRtcAec_ScaleErrorSignal;
 WebRtcAecFilterAdaptation WebRtcAec_FilterAdaptation;
 WebRtcAecOverdriveAndSuppress WebRtcAec_OverdriveAndSuppress;
 WebRtcAecComfortNoise WebRtcAec_ComfortNoise;
@@ skipping 10 matching lines @@
   return aRe * bIm + aIm * bRe;
 }
 
 static int CmpFloat(const void* a, const void* b) {
   const float* da = (const float*)a;
   const float* db = (const float*)b;
 
   return (*da > *db) - (*da < *db);
 }
 
-static void FilterFar(
-    int num_partitions,
-    int x_fft_buf_block_pos,
-    float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
-    float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
-    float y_fft[2][PART_LEN1]) {
+static void FilterFar(int num_partitions,
+                      int x_fft_buf_block_pos,
+                      float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
+                      float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
+                      float y_fft[2][PART_LEN1]) {
   int i;
   for (i = 0; i < num_partitions; i++) {
     int j;
     int xPos = (i + x_fft_buf_block_pos) * PART_LEN1;
     int pos = i * PART_LEN1;
     // Check for wrap
     if (i + x_fft_buf_block_pos >= num_partitions) {
       xPos -= num_partitions * (PART_LEN1);
     }
 
     for (j = 0; j < PART_LEN1; j++) {
-      y_fft[0][j] += MulRe(x_fft_buf[0][xPos + j],
-                           x_fft_buf[1][xPos + j],
-                           h_fft_buf[0][pos + j],
-                           h_fft_buf[1][pos + j]);
-      y_fft[1][j] += MulIm(x_fft_buf[0][xPos + j],
-                           x_fft_buf[1][xPos + j],
-                           h_fft_buf[0][pos + j],
-                           h_fft_buf[1][pos + j]);
+      y_fft[0][j] += MulRe(x_fft_buf[0][xPos + j], x_fft_buf[1][xPos + j],
+                           h_fft_buf[0][pos + j], h_fft_buf[1][pos + j]);
+      y_fft[1][j] += MulIm(x_fft_buf[0][xPos + j], x_fft_buf[1][xPos + j],
+                           h_fft_buf[0][pos + j], h_fft_buf[1][pos + j]);
     }
   }
 }
 
 static void ScaleErrorSignal(int extended_filter_enabled,
                              float normal_mu,
                              float normal_error_threshold,
                              float x_pow[PART_LEN1],
                              float ef[2][PART_LEN1]) {
   const float mu = extended_filter_enabled ? kExtendedMu : normal_mu;
@@ skipping 12 matching lines @@
       ef[0][i] *= abs_ef;
       ef[1][i] *= abs_ef;
     }
 
     // Stepsize factor
     ef[0][i] *= mu;
     ef[1][i] *= mu;
   }
 }
 
-
 static void FilterAdaptation(
     int num_partitions,
     int x_fft_buf_block_pos,
     float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
     float e_fft[2][PART_LEN1],
     float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1]) {
   int i, j;
   float fft[PART_LEN2];
   for (i = 0; i < num_partitions; i++) {
     int xPos = (i + x_fft_buf_block_pos) * (PART_LEN1);
     int pos;
     // Check for wrap
     if (i + x_fft_buf_block_pos >= num_partitions) {
       xPos -= num_partitions * PART_LEN1;
     }
 
     pos = i * PART_LEN1;
 
     for (j = 0; j < PART_LEN; j++) {
-
-      fft[2 * j] = MulRe(x_fft_buf[0][xPos + j],
-                         -x_fft_buf[1][xPos + j],
-                         e_fft[0][j],
-                         e_fft[1][j]);
-      fft[2 * j + 1] = MulIm(x_fft_buf[0][xPos + j],
-                             -x_fft_buf[1][xPos + j],
-                             e_fft[0][j],
-                             e_fft[1][j]);
+      fft[2 * j] = MulRe(x_fft_buf[0][xPos + j], -x_fft_buf[1][xPos + j],
+                         e_fft[0][j], e_fft[1][j]);
+      fft[2 * j + 1] = MulIm(x_fft_buf[0][xPos + j], -x_fft_buf[1][xPos + j],
+                             e_fft[0][j], e_fft[1][j]);
     }
-    fft[1] = MulRe(x_fft_buf[0][xPos + PART_LEN],
-                   -x_fft_buf[1][xPos + PART_LEN],
-                   e_fft[0][PART_LEN],
-                   e_fft[1][PART_LEN]);
+    fft[1] =
+        MulRe(x_fft_buf[0][xPos + PART_LEN], -x_fft_buf[1][xPos + PART_LEN],
+              e_fft[0][PART_LEN], e_fft[1][PART_LEN]);
 
     aec_rdft_inverse_128(fft);
     memset(fft + PART_LEN, 0, sizeof(float) * PART_LEN);
 
     // fft scaling
     {
       float scale = 2.0f / PART_LEN2;
       for (j = 0; j < PART_LEN; j++) {
         fft[j] *= scale;
       }
@@ skipping 41 matching lines @@
   float wfEnMax = 0;
   int i;
   int delay = 0;
 
   for (i = 0; i < aec->num_partitions; i++) {
     int j;
     int pos = i * PART_LEN1;
     float wfEn = 0;
     for (j = 0; j < PART_LEN1; j++) {
       wfEn += aec->wfBuf[0][pos + j] * aec->wfBuf[0][pos + j] +
-          aec->wfBuf[1][pos + j] * aec->wfBuf[1][pos + j];
+              aec->wfBuf[1][pos + j] * aec->wfBuf[1][pos + j];
     }
 
     if (wfEn > wfEnMax) {
       wfEnMax = wfEn;
       delay = i;
     }
   }
   return delay;
 }
 
 // Threshold to protect against the ill-effects of a zero far-end.
 const float WebRtcAec_kMinFarendPSD = 15;
 
 // Updates the following smoothed  Power Spectral Densities (PSD):
 //  - sd  : near-end
 //  - se  : residual echo
 //  - sx  : far-end
 //  - sde : cross-PSD of near-end and residual echo
 //  - sxd : cross-PSD of near-end and far-end
 //
 // In addition to updating the PSDs, also the filter diverge state is
 // determined.
 static void SmoothedPSD(AecCore* aec,
                         float efw[2][PART_LEN1],
                         float dfw[2][PART_LEN1],
                         float xfw[2][PART_LEN1],
                         int* extreme_filter_divergence) {
   // Power estimate smoothing coefficients.
-  const float* ptrGCoh = aec->extended_filter_enabled
-      ? WebRtcAec_kExtendedSmoothingCoefficients[aec->mult - 1]
-      : WebRtcAec_kNormalSmoothingCoefficients[aec->mult - 1];
+  const float* ptrGCoh =
+      aec->extended_filter_enabled
+          ? WebRtcAec_kExtendedSmoothingCoefficients[aec->mult - 1]
+          : WebRtcAec_kNormalSmoothingCoefficients[aec->mult - 1];
   int i;
   float sdSum = 0, seSum = 0;
 
   for (i = 0; i < PART_LEN1; i++) {
     aec->sd[i] = ptrGCoh[0] * aec->sd[i] +
                  ptrGCoh[1] * (dfw[0][i] * dfw[0][i] + dfw[1][i] * dfw[1][i]);
     aec->se[i] = ptrGCoh[0] * aec->se[i] +
                  ptrGCoh[1] * (efw[0][i] * efw[0][i] + efw[1][i] * efw[1][i]);
     // We threshold here to protect against the ill-effects of a zero farend.
     // The threshold is not arbitrarily chosen, but balances protection and
     // adverse interaction with the algorithm's tuning.
     // TODO(bjornv): investigate further why this is so sensitive.
-    aec->sx[i] =
-        ptrGCoh[0] * aec->sx[i] +
-        ptrGCoh[1] * WEBRTC_SPL_MAX(
-            xfw[0][i] * xfw[0][i] + xfw[1][i] * xfw[1][i],
-            WebRtcAec_kMinFarendPSD);
+    aec->sx[i] = ptrGCoh[0] * aec->sx[i] +
+                 ptrGCoh[1] * WEBRTC_SPL_MAX(
+                                  xfw[0][i] * xfw[0][i] + xfw[1][i] * xfw[1][i],
+                                  WebRtcAec_kMinFarendPSD);
 
     aec->sde[i][0] =
         ptrGCoh[0] * aec->sde[i][0] +
         ptrGCoh[1] * (dfw[0][i] * efw[0][i] + dfw[1][i] * efw[1][i]);
     aec->sde[i][1] =
         ptrGCoh[0] * aec->sde[i][1] +
         ptrGCoh[1] * (dfw[0][i] * efw[1][i] - dfw[1][i] * efw[0][i]);
 
     aec->sxd[i][0] =
         ptrGCoh[0] * aec->sxd[i][0] +
@@ skipping 109 matching lines @@
     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) {
-
     // average noise scale
     // average over second half of freq spectrum (i.e., 4->8khz)
     // TODO: 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]);
     }
     noiseAvg /= (float)num;
 
     // average nlp scale
@@ skipping 117 matching lines @@
   const float noisyPower = 300000.0f * 2.0f / PART_LEN2;
 
   float actThreshold;
   float echo, suppressedEcho;
 
   if (aec->echoState) {  // Check if echo is likely present
     aec->stateCounter++;
   }
 
   if (aec->farlevel.frcounter == 0) {
-
     if (aec->farlevel.minlevel < noisyPower) {
       actThreshold = actThresholdClean;
     } else {
       actThreshold = actThresholdNoisy;
     }
 
     if ((aec->stateCounter > (0.5f * countLen * subCountLen)) &&
         (aec->farlevel.sfrcounter == 0)
 
         // Estimate in active far-end segments only
-        &&
-        (aec->farlevel.averagelevel >
-         (actThreshold * aec->farlevel.minlevel))) {
-
+        && (aec->farlevel.averagelevel >
+            (actThreshold * aec->farlevel.minlevel))) {
       // Subtract noise power
       echo = aec->nearlevel.averagelevel - safety * aec->nearlevel.minlevel;
 
       // ERL
       dtmp = 10 * (float)log10(aec->farlevel.averagelevel /
                                    aec->nearlevel.averagelevel +
                                1e-10f);
       dtmp2 = 10 * (float)log10(aec->farlevel.averagelevel / echo + 1e-10f);
 
       aec->erl.instant = dtmp;
@@ skipping 113 matching lines @@
       break;
     }
   }
   // Account for lookahead.
   self->delay_median = (median - lookahead) * kMsPerBlock;
 
   // Calculate the L1 norm, with median value as central moment.
   for (i = 0; i < kHistorySizeBlocks; i++) {
     l1_norm += abs(i - median) * self->delay_histogram[i];
   }
-  self->delay_std = (int)((l1_norm + self->num_delay_values / 2) /
-      self->num_delay_values) * kMsPerBlock;
+  self->delay_std =
+      (int)((l1_norm + self->num_delay_values / 2) / self->num_delay_values) *
+      kMsPerBlock;
 
   // Determine fraction of delays that are out of bounds, that is, either
   // negative (anti-causal system) or larger than the AEC filter length.
   {
     int num_delays_out_of_bounds = self->num_delay_values;
-    const int histogram_length = sizeof(self->delay_histogram) /
-      sizeof(self->delay_histogram[0]);
+    const int histogram_length =
+        sizeof(self->delay_histogram) / sizeof(self->delay_histogram[0]);
     for (i = lookahead; i < lookahead + self->num_partitions; ++i) {
       if (i < histogram_length)
         num_delays_out_of_bounds -= self->delay_histogram[i];
     }
-    self->fraction_poor_delays = (float)num_delays_out_of_bounds /
-        self->num_delay_values;
+    self->fraction_poor_delays =
+        (float)num_delays_out_of_bounds / self->num_delay_values;
   }
 
   // Reset histogram.
   memset(self->delay_histogram, 0, sizeof(self->delay_histogram));
   self->num_delay_values = 0;
 
   return;
 }
 
 static void ScaledInverseFft(float freq_data[2][PART_LEN1],
                              float time_data[PART_LEN2],
                              float scale,
                              int conjugate) {
   int i;
   const float normalization = scale / ((float)PART_LEN2);
   const float sign = (conjugate ? -1 : 1);
   time_data[0] = freq_data[0][0] * normalization;
   time_data[1] = freq_data[0][PART_LEN] * normalization;
   for (i = 1; i < PART_LEN; i++) {
     time_data[2 * i] = freq_data[0][i] * normalization;
     time_data[2 * i + 1] = sign * freq_data[1][i] * normalization;
   }
   aec_rdft_inverse_128(time_data);
 }
 
-
-static void Fft(float time_data[PART_LEN2],
-                float freq_data[2][PART_LEN1]) {
+static void Fft(float time_data[PART_LEN2], float freq_data[2][PART_LEN1]) {
   int i;
   aec_rdft_forward_128(time_data);
 
   // Reorder fft output data.
   freq_data[1][0] = 0;
   freq_data[1][PART_LEN] = 0;
   freq_data[0][0] = time_data[0];
   freq_data[0][PART_LEN] = time_data[1];
   for (i = 1; i < PART_LEN; i++) {
     freq_data[0][i] = time_data[2 * i];
@@ skipping 20 matching lines @@
   //    negative |last_delay| is an invalid one.
   // 2. Verify that there is a delay change.  In addition, only allow a change
   //    if the delay is outside a certain region taking the AEC filter length
   //    into account.
   // TODO(bjornv): Investigate if we can remove the non-zero delay change check.
   // 3. Only allow delay correction if the delay estimation quality exceeds
   //    |delay_quality_threshold|.
   // 4. Finally, verify that the proposed |delay_correction| is feasible by
   //    comparing with the size of the far-end buffer.
   last_delay = WebRtc_last_delay(self->delay_estimator);
-  if ((last_delay >= 0) &&
-      (last_delay != self->previous_delay) &&
+  if ((last_delay >= 0) && (last_delay != self->previous_delay) &&
       (WebRtc_last_delay_quality(self->delay_estimator) >
-           self->delay_quality_threshold)) {
+       self->delay_quality_threshold)) {
     int delay = last_delay - WebRtc_lookahead(self->delay_estimator);
     // Allow for a slack in the actual delay, defined by a |lower_bound| and an
     // |upper_bound|.  The adaptive echo cancellation filter is currently
     // |num_partitions| (of 64 samples) long.  If the delay estimate is negative
     // or at least 3/4 of the filter length we open up for correction.
     const int lower_bound = 0;
     const int upper_bound = self->num_partitions * 3 / 4;
     const int do_correction = delay <= lower_bound || delay > upper_bound;
     if (do_correction == 1) {
       int available_read = (int)WebRtc_available_read(self->far_time_buf);
@@ skipping 13 matching lines @@
       } else {
         self->previous_delay = last_delay;
         ++self->delay_correction_count;
       }
     }
   }
   // Update the |delay_quality_threshold| once we have our first delay
   // correction.
   if (self->delay_correction_count > 0) {
     float delay_quality = WebRtc_last_delay_quality(self->delay_estimator);
-    delay_quality = (delay_quality > kDelayQualityThresholdMax ?
-        kDelayQualityThresholdMax : delay_quality);
+    delay_quality =
+        (delay_quality > kDelayQualityThresholdMax ? kDelayQualityThresholdMax
+                                                   : delay_quality);
     self->delay_quality_threshold =
-        (delay_quality > self->delay_quality_threshold ? delay_quality :
-            self->delay_quality_threshold);
+        (delay_quality > self->delay_quality_threshold
+             ? delay_quality
+             : self->delay_quality_threshold);
   }
   return delay_correction;
 }
 
-static void EchoSubtraction(
-    AecCore* aec,
-    int num_partitions,
-    int x_fft_buf_block_pos,
-    int extended_filter_enabled,
-    float normal_mu,
-    float normal_error_threshold,
-    float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
-    float* const y,
-    float x_pow[PART_LEN1],
-    float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
-    float echo_subtractor_output[PART_LEN]) {
+static void EchoSubtraction(AecCore* aec,
+                            int num_partitions,
+                            int x_fft_buf_block_pos,
+                            int extended_filter_enabled,
+                            float normal_mu,
+                            float normal_error_threshold,
+                            float x_fft_buf[2]
+                                           [kExtendedNumPartitions * PART_LEN1],
+                            float* const y,
+                            float x_pow[PART_LEN1],
+                            float h_fft_buf[2]
+                                           [kExtendedNumPartitions * PART_LEN1],
+                            float echo_subtractor_output[PART_LEN]) {
   float s_fft[2][PART_LEN1];
   float e_extended[PART_LEN2];
   float s_extended[PART_LEN2];
-  float *s;
+  float* s;
   float e[PART_LEN];
   float e_fft[2][PART_LEN1];
   int i;
   memset(s_fft, 0, sizeof(s_fft));
 
   // Conditionally reset the echo subtraction filter if the filter has diverged
   // significantly.
-  if (!aec->extended_filter_enabled &&
-      aec->extreme_filter_divergence) {
+  if (!aec->extended_filter_enabled && aec->extreme_filter_divergence) {
     memset(aec->wfBuf, 0, sizeof(aec->wfBuf));
     aec->extreme_filter_divergence = 0;
   }
 
   // Produce echo estimate s_fft.
-  WebRtcAec_FilterFar(num_partitions,
-                      x_fft_buf_block_pos,
-                      x_fft_buf,
-                      h_fft_buf,
+  WebRtcAec_FilterFar(num_partitions, x_fft_buf_block_pos, x_fft_buf, h_fft_buf,
                       s_fft);
 
   // Compute the time-domain echo estimate s.
   ScaledInverseFft(s_fft, s_extended, 2.0f, 0);
   s = &s_extended[PART_LEN];
 
   // Compute the time-domain echo prediction error.
   for (i = 0; i < PART_LEN; ++i) {
     e[i] = y[i] - s[i];
   }
 
   // Compute the frequency domain echo prediction error.
   memset(e_extended, 0, sizeof(float) * PART_LEN);
   memcpy(e_extended + PART_LEN, e, sizeof(float) * PART_LEN);
   Fft(e_extended, e_fft);
 
-  RTC_AEC_DEBUG_RAW_WRITE(aec->e_fft_file,
-                          &e_fft[0][0],
+  RTC_AEC_DEBUG_RAW_WRITE(aec->e_fft_file, &e_fft[0][0],
                           sizeof(e_fft[0][0]) * PART_LEN1 * 2);
 
   // Scale error signal inversely with far power.
-  WebRtcAec_ScaleErrorSignal(extended_filter_enabled,
-                             normal_mu,
-                             normal_error_threshold,
-                             x_pow,
-                             e_fft);
-  WebRtcAec_FilterAdaptation(num_partitions,
-                             x_fft_buf_block_pos,
-                             x_fft_buf,
-                             e_fft,
-                             h_fft_buf);
+  WebRtcAec_ScaleErrorSignal(extended_filter_enabled, normal_mu,
+                             normal_error_threshold, x_pow, e_fft);
+  WebRtcAec_FilterAdaptation(num_partitions, x_fft_buf_block_pos, x_fft_buf,
+                             e_fft, h_fft_buf);
   memcpy(echo_subtractor_output, e, sizeof(float) * PART_LEN);
 }
 
 static void EchoSuppression(AecCore* aec,
                             float farend[PART_LEN2],
                             float* echo_subtractor_output,
                             float* output,
                             float* const* outputH) {
   float efw[2][PART_LEN1];
   float xfw[2][PART_LEN1];
@@ skipping 17 matching lines @@
   const float* min_overdrive = aec->extended_filter_enabled
                                    ? kExtendedMinOverDrive
                                    : kNormalMinOverDrive;
 
   // Filter energy
   const int delayEstInterval = 10 * aec->mult;
 
   float* xfw_ptr = NULL;
 
   // Update eBuf with echo subtractor output.
-  memcpy(aec->eBuf + PART_LEN,
-         echo_subtractor_output,
+  memcpy(aec->eBuf + PART_LEN, echo_subtractor_output,
          sizeof(float) * PART_LEN);
 
   // Analysis filter banks for the echo suppressor.
   // Windowed near-end ffts.
   WindowData(fft, aec->dBuf);
   aec_rdft_forward_128(fft);
   StoreAsComplex(fft, dfw);
 
   // Windowed echo suppressor output ffts.
   WindowData(fft, aec->eBuf);
@@ skipping 10 matching lines @@
   // Buffer far.
   memcpy(aec->xfwBuf, xfw_ptr, sizeof(float) * 2 * PART_LEN1);
 
   aec->delayEstCtr++;
   if (aec->delayEstCtr == delayEstInterval) {
     aec->delayEstCtr = 0;
     aec->delayIdx = WebRtcAec_PartitionDelay(aec);
   }
 
   // Use delayed far.
-  memcpy(xfw,
-         aec->xfwBuf + aec->delayIdx * PART_LEN1,
+  memcpy(xfw, aec->xfwBuf + aec->delayIdx * PART_LEN1,
          sizeof(xfw[0][0]) * 2 * PART_LEN1);
 
   WebRtcAec_SubbandCoherence(aec, efw, dfw, xfw, fft, cohde, cohxd,
                              &aec->extreme_filter_divergence);
 
   // Select the microphone signal as output if the filter is deemed to have
   // diverged.
   if (aec->divergeState) {
     memcpy(efw, dfw, sizeof(efw[0][0]) * 2 * PART_LEN1);
   }
@@ skipping 30 matching lines @@
       hNlFb = hNlDeAvg;
       hNlFbLow = hNlDeAvg;
     } else {
       for (i = 0; i < PART_LEN1; i++) {
         hNl[i] = 1 - cohxd[i];
       }
       hNlFb = hNlXdAvg;
       hNlFbLow = hNlXdAvg;
     }
   } else {
-
     if (aec->stNearState == 1) {
       aec->echoState = 0;
       memcpy(hNl, cohde, sizeof(hNl));
       hNlFb = hNlDeAvg;
       hNlFbLow = hNlDeAvg;
     } else {
       aec->echoState = 1;
       for (i = 0; i < PART_LEN1; i++) {
         hNl[i] = WEBRTC_SPL_MIN(cohde[i], 1 - cohxd[i]);
       }
@@ skipping 54 matching lines @@
     // scaling only in UpdateMetrics().
     UpdateLevel(&aec->nlpoutlevel, CalculatePower(fft, PART_LEN2));
   }
 
   // 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.
-    output[i] = WEBRTC_SPL_SAT(
-        WEBRTC_SPL_WORD16_MAX, output[i], WEBRTC_SPL_WORD16_MIN);
+    output[i] =
+        WEBRTC_SPL_SAT(WEBRTC_SPL_WORD16_MAX, output[i], WEBRTC_SPL_WORD16_MIN);
   }
   memcpy(aec->outBuf, &fft[PART_LEN], PART_LEN * sizeof(aec->outBuf[0]));
 
   // For H band
   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
     ScaledInverseFft(comfortNoiseHband, fft, 2.0f, 0);
 
     // compute gain factor
     for (j = 0; j < aec->num_bands - 1; ++j) {
       for (i = 0; i < PART_LEN; i++) {
         outputH[j][i] = aec->dBufH[j][i] * nlpGainHband;
       }
     }
 
     // Add some comfort noise where Hband is attenuated.
     for (i = 0; i < PART_LEN; i++) {
       outputH[0][i] += cnScaleHband * fft[i];
     }
 
     // Saturate output to keep it in the allowed range.
     for (j = 0; j < aec->num_bands - 1; ++j) {
       for (i = 0; i < PART_LEN; i++) {
-        outputH[j][i] = WEBRTC_SPL_SAT(
-            WEBRTC_SPL_WORD16_MAX, outputH[j][i], WEBRTC_SPL_WORD16_MIN);
+        outputH[j][i] = WEBRTC_SPL_SAT(WEBRTC_SPL_WORD16_MAX, outputH[j][i],
+                                       WEBRTC_SPL_WORD16_MIN);
       }
     }
-
   }
 
   // Copy the current block to the old position.
   memcpy(aec->dBuf, aec->dBuf + PART_LEN, sizeof(float) * PART_LEN);
   memcpy(aec->eBuf, aec->eBuf + PART_LEN, sizeof(float) * PART_LEN);
 
   // Copy the current block to the old position for H band
   for (j = 0; j < aec->num_bands - 1; ++j) {
     memcpy(aec->dBufH[j], aec->dBufH[j] + PART_LEN, sizeof(float) * PART_LEN);
   }
 
-  memmove(aec->xfwBuf + PART_LEN1,
-          aec->xfwBuf,
+  memmove(aec->xfwBuf + PART_LEN1, aec->xfwBuf,
           sizeof(aec->xfwBuf) - sizeof(complex_t) * PART_LEN1);
 }
 
 static void ProcessBlock(AecCore* aec) {
   size_t i;
 
   float fft[PART_LEN2];
   float xf[2][PART_LEN1];
   float df[2][PART_LEN1];
   float far_spectrum = 0.0f;
@@ skipping 18 matching lines @@
   float outputH[NUM_HIGH_BANDS_MAX][PART_LEN];
   float* outputH_ptr[NUM_HIGH_BANDS_MAX];
   float* xf_ptr = NULL;
 
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
     outputH_ptr[i] = outputH[i];
   }
 
   // Concatenate old and new nearend blocks.
   for (i = 0; i < aec->num_bands - 1; ++i) {
-    WebRtc_ReadBuffer(aec->nearFrBufH[i],
-                      (void**)&nearend_ptr,
-                      nearend,
+    WebRtc_ReadBuffer(aec->nearFrBufH[i], (void**)&nearend_ptr, nearend,
                       PART_LEN);
     memcpy(aec->dBufH[i] + PART_LEN, nearend_ptr, sizeof(nearend));
   }
   WebRtc_ReadBuffer(aec->nearFrBuf, (void**)&nearend_ptr, nearend, PART_LEN);
   memcpy(aec->dBuf + PART_LEN, nearend_ptr, sizeof(nearend));
 
   // We should always have at least one element stored in |far_buf|.
   assert(WebRtc_available_read(aec->far_time_buf) > 0);
   WebRtc_ReadBuffer(aec->far_time_buf, (void**)&farend_ptr, farend, 1);
 
@@ skipping 62 matching lines @@
         aec->dInitMinPow[i] = aec->dMinPow[i];
       }
     }
     aec->noisePow = aec->dInitMinPow;
   } else {
     aec->noisePow = aec->dMinPow;
   }
 
   // Block wise delay estimation used for logging
   if (aec->delay_logging_enabled) {
-    if (WebRtc_AddFarSpectrumFloat(
-            aec->delay_estimator_farend, abs_far_spectrum, PART_LEN1) == 0) {
+    if (WebRtc_AddFarSpectrumFloat(aec->delay_estimator_farend,
+                                   abs_far_spectrum, PART_LEN1) == 0) {
       int delay_estimate = WebRtc_DelayEstimatorProcessFloat(
           aec->delay_estimator, abs_near_spectrum, PART_LEN1);
       if (delay_estimate >= 0) {
         // Update delay estimate buffer.
         aec->delay_histogram[delay_estimate]++;
         aec->num_delay_values++;
       }
       if (aec->delay_metrics_delivered == 1 &&
           aec->num_delay_values >= kDelayMetricsAggregationWindow) {
         UpdateDelayMetrics(aec);
       }
     }
   }
 
   // Update the xfBuf block position.
   aec->xfBufBlockPos--;
   if (aec->xfBufBlockPos == -1) {
     aec->xfBufBlockPos = aec->num_partitions - 1;
   }
 
   // Buffer xf
-  memcpy(aec->xfBuf[0] + aec->xfBufBlockPos * PART_LEN1,
-         xf_ptr,
+  memcpy(aec->xfBuf[0] + aec->xfBufBlockPos * PART_LEN1, xf_ptr,
          sizeof(float) * PART_LEN1);
-  memcpy(aec->xfBuf[1] + aec->xfBufBlockPos * PART_LEN1,
-         &xf_ptr[PART_LEN1],
+  memcpy(aec->xfBuf[1] + aec->xfBufBlockPos * PART_LEN1, &xf_ptr[PART_LEN1],
          sizeof(float) * PART_LEN1);
 
   // Perform echo subtraction.
-  EchoSubtraction(aec,
-                  aec->num_partitions,
-                  aec->xfBufBlockPos,
+  EchoSubtraction(aec, aec->num_partitions, aec->xfBufBlockPos,
                   aec->extended_filter_enabled,
-                  aec->normal_mu,
-                  aec->normal_error_threshold,
-                  aec->xfBuf,
-                  nearend_ptr,
-                  aec->xPow,
-                  aec->wfBuf,
+                  aec->normal_mu, aec->normal_error_threshold, aec->xfBuf,
+                  nearend_ptr, aec->xPow, aec->wfBuf,
                   echo_subtractor_output);
 
   RTC_AEC_DEBUG_WAV_WRITE(aec->outLinearFile, echo_subtractor_output, PART_LEN);
 
   if (aec->metricsMode == 1) {
     UpdateLevel(&aec->linoutlevel,
                 CalculatePower(echo_subtractor_output, PART_LEN));
   }
 
   // Perform echo suppression.
@@ skipping 26 matching lines @@
     return NULL;
   }
 
   aec->outFrBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN, sizeof(float));
   if (!aec->outFrBuf) {
     WebRtcAec_FreeAec(aec);
     return NULL;
   }
 
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
-    aec->nearFrBufH[i] = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
-                                             sizeof(float));
+    aec->nearFrBufH[i] =
+        WebRtc_CreateBuffer(FRAME_LEN + PART_LEN, sizeof(float));
     if (!aec->nearFrBufH[i]) {
       WebRtcAec_FreeAec(aec);
       return NULL;
     }
-    aec->outFrBufH[i] = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
-                                            sizeof(float));
+    aec->outFrBufH[i] =
+        WebRtc_CreateBuffer(FRAME_LEN + PART_LEN, sizeof(float));
     if (!aec->outFrBufH[i]) {
       WebRtcAec_FreeAec(aec);
       return NULL;
     }
   }
 
   // Create far-end buffers.
   // For bit exactness with legacy code, each element in |far_time_buf| is
   // supposed to contain |PART_LEN2| samples with an overlap of |PART_LEN|
   // samples from the last frame.
@@ skipping 40 matching lines @@
   WebRtcAec_FilterFar = FilterFar;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignal;
   WebRtcAec_FilterAdaptation = FilterAdaptation;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppress;
   WebRtcAec_ComfortNoise = ComfortNoise;
   WebRtcAec_SubbandCoherence = SubbandCoherence;
   WebRtcAec_StoreAsComplex = StoreAsComplex;
   WebRtcAec_PartitionDelay = PartitionDelay;
   WebRtcAec_WindowData = WindowData;
 
-
 #if defined(WEBRTC_ARCH_X86_FAMILY)
   if (WebRtc_GetCPUInfo(kSSE2)) {
     WebRtcAec_InitAec_SSE2();
   }
 #endif
 
 #if defined(MIPS_FPU_LE)
   WebRtcAec_InitAec_mips();
 #endif
 
@@ skipping 61 matching lines @@
   }
 
   // Initialize far-end buffers.
   WebRtc_InitBuffer(aec->far_time_buf);
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     int process_rate = sampFreq > 16000 ? 16000 : sampFreq;
     RTC_AEC_DEBUG_WAV_REOPEN("aec_far", aec->instance_index,
                              aec->debug_dump_count, process_rate,
-                             &aec->farFile );
+                             &aec->farFile);
     RTC_AEC_DEBUG_WAV_REOPEN("aec_near", aec->instance_index,
                              aec->debug_dump_count, process_rate,
                              &aec->nearFile);
     RTC_AEC_DEBUG_WAV_REOPEN("aec_out", aec->instance_index,
                              aec->debug_dump_count, process_rate,
-                             &aec->outFile );
+                             &aec->outFile);
     RTC_AEC_DEBUG_WAV_REOPEN("aec_out_linear", aec->instance_index,
                              aec->debug_dump_count, process_rate,
                              &aec->outLinearFile);
   }
 
-  RTC_AEC_DEBUG_RAW_OPEN("aec_e_fft",
-                         aec->debug_dump_count,
-                         &aec->e_fft_file);
+  RTC_AEC_DEBUG_RAW_OPEN("aec_e_fft", aec->debug_dump_count, &aec->e_fft_file);
 
   ++aec->debug_dump_count;
 #endif
   aec->system_delay = 0;
 
   if (WebRtc_InitDelayEstimatorFarend(aec->delay_estimator_farend) != 0) {
     return -1;
   }
   if (WebRtc_InitDelayEstimator(aec->delay_estimator) != 0) {
     return -1;
@@ skipping 65 matching lines @@
   }
 
   // Holds the last block written to
   aec->xfBufBlockPos = 0;
   // TODO: Investigate need for these initializations. Deleting them doesn't
   //       change the output at all and yields 0.4% overall speedup.
   memset(aec->xfBuf, 0, sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
   memset(aec->wfBuf, 0, sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
   memset(aec->sde, 0, sizeof(complex_t) * PART_LEN1);
   memset(aec->sxd, 0, sizeof(complex_t) * PART_LEN1);
-  memset(
-      aec->xfwBuf, 0, sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
+  memset(aec->xfwBuf, 0,
+         sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
   memset(aec->se, 0, sizeof(float) * PART_LEN1);
 
   // To prevent numerical instability in the first block.
   for (i = 0; i < PART_LEN1; i++) {
     aec->sd[i] = 1;
   }
   for (i = 0; i < PART_LEN1; i++) {
     aec->sx[i] = 1;
   }
 
@@ skipping 75 matching lines @@
   // give a guess on how much we need to shift far-end buffers to align with
   // the near-end signal.  The other delay estimation algorithm uses the
   // far- and near-end signals to find the offset between them.  This one
   // (called "signal delay") is then used to fine tune the alignment, or
   // simply compensate for errors in the system based one.
   // Note that the two algorithms operate independently.  Currently, we only
   // allow one algorithm to be turned on.
 
   assert(aec->num_bands == num_bands);
 
-  for (j = 0; j < num_samples; j+= FRAME_LEN) {
+  for (j = 0; j < num_samples; j += FRAME_LEN) {
     // TODO(bjornv): Change the near-end buffer handling to be the same as for
     // far-end, that is, with a near_pre_buf.
     // Buffer the near-end frame.
     WebRtc_WriteBuffer(aec->nearFrBuf, &nearend[0][j], FRAME_LEN);
     // For H band
     for (i = 1; i < num_bands; ++i) {
       WebRtc_WriteBuffer(aec->nearFrBufH[i - 1], &nearend[i][j], FRAME_LEN);
     }
 
     // 1) At most we process |aec->mult|+1 partitions in 10 ms. Make sure we
     // have enough far-end data for that by stuffing the buffer if the
     // |system_delay| indicates others.
     if (aec->system_delay < FRAME_LEN) {
       // We don't have enough data so we rewind 10 ms.
       WebRtcAec_MoveFarReadPtr(aec, -(aec->mult + 1));
     }
 
     if (!aec->delay_agnostic_enabled) {
       // 2 a) Compensate for a possible change in the system delay.
 
       // TODO(bjornv): Investigate how we should round the delay difference;
       // right now we know that incoming |knownDelay| is underestimated when
       // it's less than |aec->knownDelay|. We therefore, round (-32) in that
       // direction. In the other direction, we don't have this situation, but
       // might flush one partition too little. This can cause non-causality,
       // which should be investigated. Maybe, allow for a non-symmetric
       // rounding, like -16.
       int move_elements = (aec->knownDelay - knownDelay - 32) / PART_LEN;
-      int moved_elements =
-          WebRtc_MoveReadPtr(aec->far_time_buf, move_elements);
+      int moved_elements = WebRtc_MoveReadPtr(aec->far_time_buf, move_elements);
       aec->knownDelay -= moved_elements * PART_LEN;
     } else {
       // 2 b) Apply signal based delay correction.
       int move_elements = SignalBasedDelayCorrection(aec);
-      int moved_elements =
-          WebRtc_MoveReadPtr(aec->far_time_buf, move_elements);
-      int far_near_buffer_diff = WebRtc_available_read(aec->far_time_buf) -
+      int moved_elements = WebRtc_MoveReadPtr(aec->far_time_buf, move_elements);
+      int far_near_buffer_diff =
+          WebRtc_available_read(aec->far_time_buf) -
           WebRtc_available_read(aec->nearFrBuf) / PART_LEN;
       WebRtc_SoftResetDelayEstimator(aec->delay_estimator, moved_elements);
       WebRtc_SoftResetDelayEstimatorFarend(aec->delay_estimator_farend,
                                            moved_elements);
       aec->signal_delay_correction += moved_elements;
       // If we rely on reported system delay values only, a buffer underrun here
       // can never occur since we've taken care of that in 1) above.  Here, we
       // apply signal based delay correction and can therefore end up with
       // buffer underruns since the delay estimation can be wrong.  We therefore
       // stuff the buffer with enough elements if needed.
@@ skipping 22 matching lines @@
     }
     // Obtain an output frame.
     WebRtc_ReadBuffer(aec->outFrBuf, NULL, &out[0][j], FRAME_LEN);
     // For H bands.
     for (i = 1; i < num_bands; ++i) {
       WebRtc_ReadBuffer(aec->outFrBufH[i - 1], NULL, &out[i][j], FRAME_LEN);
     }
   }
 }
 
-int WebRtcAec_GetDelayMetricsCore(AecCore* self, int* median, int* std,
+int WebRtcAec_GetDelayMetricsCore(AecCore* self,
+                                  int* median,
+                                  int* std,
                                   float* fraction_poor_delays) {
   assert(self != NULL);
   assert(median != NULL);
   assert(std != NULL);
 
   if (self->delay_logging_enabled == 0) {
     // Logging disabled.
     return -1;
   }
 
   if (self->delay_metrics_delivered == 0) {
     UpdateDelayMetrics(self);
     self->delay_metrics_delivered = 1;
   }
   *median = self->delay_median;
   *std = self->delay_std;
   *fraction_poor_delays = self->fraction_poor_delays;
 
   return 0;
 }
 
-int WebRtcAec_echo_state(AecCore* self) { return self->echoState; }
+int WebRtcAec_echo_state(AecCore* self) {
+  return self->echoState;
+}
 
 void WebRtcAec_GetEchoStats(AecCore* self,
                             Stats* erl,
                             Stats* erle,
                             Stats* a_nlp) {
   assert(erl != NULL);
   assert(erle != NULL);
   assert(a_nlp != NULL);
   *erl = self->erl;
   *erle = self->erle;
@@ skipping 30 matching lines @@
   self->extended_filter_enabled = enable;
   self->num_partitions = enable ? kExtendedNumPartitions : kNormalNumPartitions;
   // Update the delay estimator with filter length.  See InitAEC() for details.
   WebRtc_set_allowed_offset(self->delay_estimator, self->num_partitions / 2);
 }
 
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
-int WebRtcAec_system_delay(AecCore* self) { return self->system_delay; }
+int WebRtcAec_system_delay(AecCore* self) {
+  return self->system_delay;
+}
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }