Clang format changes

webrtc/modules/audio_processing/aec/aec_core_sse2.c

 /*
  *  Copyright (c) 2011 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 11 matching lines @@
 #include "webrtc/modules/audio_processing/aec/aec_rdft.h"
 
 __inline static float MulRe(float aRe, float aIm, float bRe, float bIm) {
   return aRe * bRe - aIm * bIm;
 }
 
 __inline static float MulIm(float aRe, float aIm, float bRe, float bIm) {
   return aRe * bIm + aIm * bRe;
 }
 
-static void FilterFarSSE2(
-    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 FilterFarSSE2(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);
     }
 
@@ skipping 11 matching lines @@
       const __m128 d = _mm_mul_ps(x_fft_buf_im, h_fft_buf_re);
       const __m128 e = _mm_sub_ps(a, b);
       const __m128 f = _mm_add_ps(c, d);
       const __m128 g = _mm_add_ps(y_fft_re, e);
       const __m128 h = _mm_add_ps(y_fft_im, f);
       _mm_storeu_ps(&y_fft[0][j], g);
       _mm_storeu_ps(&y_fft[1][j], h);
     }
     // scalar code for the remaining items.
     for (; 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 ScaleErrorSignalSSE2(int extended_filter_enabled,
                                  float normal_mu,
                                  float normal_error_threshold,
                                  float x_pow[PART_LEN1],
                                  float ef[2][PART_LEN1]) {
   const __m128 k1e_10f = _mm_set1_ps(1e-10f);
   const __m128 kMu = extended_filter_enabled ? _mm_set1_ps(kExtendedMu)
-      : _mm_set1_ps(normal_mu);
+                                             : _mm_set1_ps(normal_mu);
   const __m128 kThresh = extended_filter_enabled
                              ? _mm_set1_ps(kExtendedErrorThreshold)
                              : _mm_set1_ps(normal_error_threshold);
 
   int i;
   // vectorized code (four at once)
   for (i = 0; i + 3 < PART_LEN1; i += 4) {
     const __m128 x_pow_local = _mm_loadu_ps(&x_pow[i]);
     const __m128 ef_re_base = _mm_loadu_ps(&ef[0][i]);
     const __m128 ef_im_base = _mm_loadu_ps(&ef[1][i]);
@@ skipping 17 matching lines @@
     ef_re = _mm_or_ps(ef_re, ef_re_if);
     ef_im = _mm_or_ps(ef_im, ef_im_if);
     ef_re = _mm_mul_ps(ef_re, kMu);
     ef_im = _mm_mul_ps(ef_im, kMu);
 
     _mm_storeu_ps(&ef[0][i], ef_re);
     _mm_storeu_ps(&ef[1][i], ef_im);
   }
   // scalar code for the remaining items.
   {
-    const float mu =
-        extended_filter_enabled ? kExtendedMu : normal_mu;
+    const float mu = extended_filter_enabled ? kExtendedMu : normal_mu;
     const float error_threshold = extended_filter_enabled
                                       ? kExtendedErrorThreshold
                                       : normal_error_threshold;
     for (; i < (PART_LEN1); i++) {
       float abs_ef;
       ef[0][i] /= (x_pow[i] + 1e-10f);
       ef[1][i] /= (x_pow[i] + 1e-10f);
       abs_ef = sqrtf(ef[0][i] * ef[0][i] + ef[1][i] * ef[1][i]);
 
       if (abs_ef > error_threshold) {
@@ skipping 42 matching lines @@
       const __m128 e = _mm_add_ps(a, b);
       const __m128 f = _mm_sub_ps(c, d);
       // Interleave real and imaginary parts.
       const __m128 g = _mm_unpacklo_ps(e, f);
       const __m128 h = _mm_unpackhi_ps(e, f);
       // Store
       _mm_storeu_ps(&fft[2 * j + 0], g);
       _mm_storeu_ps(&fft[2 * j + 4], h);
     }
     // ... and fixup the first imaginary entry.
-    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;
       const __m128 scale_ps = _mm_load_ps1(&scale);
       for (j = 0; j < PART_LEN; j += 4) {
         const __m128 fft_ps = _mm_loadu_ps(&fft[j]);
@@ skipping 69 matching lines @@
     static const ALIGN16_BEG int zero_biased_exponent_is_one[4] ALIGN16_END = {
         0x3F800000, 0x3F800000, 0x3F800000, 0x3F800000};
     const __m128 mantissa = _mm_and_ps(a, *((__m128*)mantissa_mask));
     const __m128 y =
         _mm_or_ps(mantissa, *((__m128*)zero_biased_exponent_is_one));
 
     // Approximate log2(y) ~= (y - 1) * pol5(y).
     //    pol5(y) = C5 * y^5 + C4 * y^4 + C3 * y^3 + C2 * y^2 + C1 * y + C0
     static const ALIGN16_BEG float ALIGN16_END C5[4] = {
         -3.4436006e-2f, -3.4436006e-2f, -3.4436006e-2f, -3.4436006e-2f};
-    static const ALIGN16_BEG float ALIGN16_END
-        C4[4] = {3.1821337e-1f, 3.1821337e-1f, 3.1821337e-1f, 3.1821337e-1f};
-    static const ALIGN16_BEG float ALIGN16_END
-        C3[4] = {-1.2315303f, -1.2315303f, -1.2315303f, -1.2315303f};
-    static const ALIGN16_BEG float ALIGN16_END
-        C2[4] = {2.5988452f, 2.5988452f, 2.5988452f, 2.5988452f};
-    static const ALIGN16_BEG float ALIGN16_END
-        C1[4] = {-3.3241990f, -3.3241990f, -3.3241990f, -3.3241990f};
-    static const ALIGN16_BEG float ALIGN16_END
-        C0[4] = {3.1157899f, 3.1157899f, 3.1157899f, 3.1157899f};
+    static const ALIGN16_BEG float ALIGN16_END C4[4] = {
+        3.1821337e-1f, 3.1821337e-1f, 3.1821337e-1f, 3.1821337e-1f};
+    static const ALIGN16_BEG float ALIGN16_END C3[4] = {
+        -1.2315303f, -1.2315303f, -1.2315303f, -1.2315303f};
+    static const ALIGN16_BEG float ALIGN16_END C2[4] = {2.5988452f, 2.5988452f,
+                                                        2.5988452f, 2.5988452f};
+    static const ALIGN16_BEG float ALIGN16_END C1[4] = {
+        -3.3241990f, -3.3241990f, -3.3241990f, -3.3241990f};
+    static const ALIGN16_BEG float ALIGN16_END C0[4] = {3.1157899f, 3.1157899f,
+                                                        3.1157899f, 3.1157899f};
     const __m128 pol5_y_0 = _mm_mul_ps(y, *((__m128*)C5));
     const __m128 pol5_y_1 = _mm_add_ps(pol5_y_0, *((__m128*)C4));
     const __m128 pol5_y_2 = _mm_mul_ps(pol5_y_1, y);
     const __m128 pol5_y_3 = _mm_add_ps(pol5_y_2, *((__m128*)C3));
     const __m128 pol5_y_4 = _mm_mul_ps(pol5_y_3, y);
     const __m128 pol5_y_5 = _mm_add_ps(pol5_y_4, *((__m128*)C2));
     const __m128 pol5_y_6 = _mm_mul_ps(pol5_y_5, y);
     const __m128 pol5_y_7 = _mm_add_ps(pol5_y_6, *((__m128*)C1));
     const __m128 pol5_y_8 = _mm_mul_ps(pol5_y_7, y);
     const __m128 pol5_y = _mm_add_ps(pol5_y_8, *((__m128*)C0));
@@ skipping 23 matching lines @@
     //         maximum relative error of 0.17%.
 
     // To avoid over/underflow, we reduce the range of input to ]-127, 129].
     static const ALIGN16_BEG float max_input[4] ALIGN16_END = {129.f, 129.f,
                                                                129.f, 129.f};
     static const ALIGN16_BEG float min_input[4] ALIGN16_END = {
         -126.99999f, -126.99999f, -126.99999f, -126.99999f};
     const __m128 x_min = _mm_min_ps(b_log2_a, *((__m128*)max_input));
     const __m128 x_max = _mm_max_ps(x_min, *((__m128*)min_input));
     // Compute n.
-    static const ALIGN16_BEG float half[4] ALIGN16_END = {0.5f, 0.5f,
-                                                          0.5f, 0.5f};
+    static const ALIGN16_BEG float half[4] ALIGN16_END = {0.5f, 0.5f, 0.5f,
+                                                          0.5f};
     const __m128 x_minus_half = _mm_sub_ps(x_max, *((__m128*)half));
     const __m128i x_minus_half_floor = _mm_cvtps_epi32(x_minus_half);
     // Compute 2^n.
     static const ALIGN16_BEG int float_exponent_bias[4] ALIGN16_END = {
         127, 127, 127, 127};
     static const int float_exponent_shift = 23;
     const __m128i two_n_exponent =
         _mm_add_epi32(x_minus_half_floor, *((__m128i*)float_exponent_bias));
     const __m128 two_n =
         _mm_castsi128_ps(_mm_slli_epi32(two_n_exponent, float_exponent_shift));
@@ skipping 76 matching lines @@
     // Suppress error signal
     efw[0][i] *= hNl[i];
     efw[1][i] *= hNl[i];
 
     // Ooura fft returns incorrect sign on imaginary component. It matters
     // here because we are making an additive change with comfort noise.
     efw[1][i] *= -1;
   }
 }
 
-__inline static void _mm_add_ps_4x1(__m128 sum, float *dst) {
+__inline static void _mm_add_ps_4x1(__m128 sum, float* dst) {
   // A+B C+D
   sum = _mm_add_ps(sum, _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(0, 0, 3, 2)));
   // A+B+C+D A+B+C+D
   sum = _mm_add_ps(sum, _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(1, 1, 1, 1)));
   _mm_store_ss(dst, sum);
 }
 
 static int PartitionDelaySSE2(const AecCore* aec) {
   // Measures the energy in each filter partition and returns the partition with
   // highest energy.
@@ skipping 39 matching lines @@
 //  - sxd : cross-PSD of near-end and far-end
 //
 // In addition to updating the PSDs, also the filter diverge state is determined
 // upon actions are taken.
 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;
-  const __m128 vec_15 =  _mm_set1_ps(WebRtcAec_kMinFarendPSD);
+  const __m128 vec_15 = _mm_set1_ps(WebRtcAec_kMinFarendPSD);
   const __m128 vec_GCoh0 = _mm_set1_ps(ptrGCoh[0]);
   const __m128 vec_GCoh1 = _mm_set1_ps(ptrGCoh[1]);
   __m128 vec_sdSum = _mm_set1_ps(0.0f);
   __m128 vec_seSum = _mm_set1_ps(0.0f);
 
   for (i = 0; i + 3 < PART_LEN1; i += 4) {
     const __m128 vec_dfw0 = _mm_loadu_ps(&dfw[0][i]);
     const __m128 vec_dfw1 = _mm_loadu_ps(&dfw[1][i]);
     const __m128 vec_efw0 = _mm_loadu_ps(&efw[0][i]);
     const __m128 vec_efw1 = _mm_loadu_ps(&efw[1][i]);
@@ skipping 12 matching lines @@
     vec_sd = _mm_add_ps(vec_sd, _mm_mul_ps(vec_dfw_sumsq, vec_GCoh1));
     vec_se = _mm_add_ps(vec_se, _mm_mul_ps(vec_efw_sumsq, vec_GCoh1));
     vec_sx = _mm_add_ps(vec_sx, _mm_mul_ps(vec_xfw_sumsq, vec_GCoh1));
     _mm_storeu_ps(&aec->sd[i], vec_sd);
     _mm_storeu_ps(&aec->se[i], vec_se);
     _mm_storeu_ps(&aec->sx[i], vec_sx);
 
     {
       const __m128 vec_3210 = _mm_loadu_ps(&aec->sde[i][0]);
       const __m128 vec_7654 = _mm_loadu_ps(&aec->sde[i + 2][0]);
-      __m128 vec_a = _mm_shuffle_ps(vec_3210, vec_7654,
-                                    _MM_SHUFFLE(2, 0, 2, 0));
-      __m128 vec_b = _mm_shuffle_ps(vec_3210, vec_7654,
-                                    _MM_SHUFFLE(3, 1, 3, 1));
+      __m128 vec_a =
+          _mm_shuffle_ps(vec_3210, vec_7654, _MM_SHUFFLE(2, 0, 2, 0));
+      __m128 vec_b =
+          _mm_shuffle_ps(vec_3210, vec_7654, _MM_SHUFFLE(3, 1, 3, 1));
       __m128 vec_dfwefw0011 = _mm_mul_ps(vec_dfw0, vec_efw0);
       __m128 vec_dfwefw0110 = _mm_mul_ps(vec_dfw0, vec_efw1);
       vec_a = _mm_mul_ps(vec_a, vec_GCoh0);
       vec_b = _mm_mul_ps(vec_b, vec_GCoh0);
-      vec_dfwefw0011 = _mm_add_ps(vec_dfwefw0011,
-                                  _mm_mul_ps(vec_dfw1, vec_efw1));
-      vec_dfwefw0110 = _mm_sub_ps(vec_dfwefw0110,
-                                  _mm_mul_ps(vec_dfw1, vec_efw0));
+      vec_dfwefw0011 =
+          _mm_add_ps(vec_dfwefw0011, _mm_mul_ps(vec_dfw1, vec_efw1));
+      vec_dfwefw0110 =
+          _mm_sub_ps(vec_dfwefw0110, _mm_mul_ps(vec_dfw1, vec_efw0));
       vec_a = _mm_add_ps(vec_a, _mm_mul_ps(vec_dfwefw0011, vec_GCoh1));
       vec_b = _mm_add_ps(vec_b, _mm_mul_ps(vec_dfwefw0110, vec_GCoh1));
       _mm_storeu_ps(&aec->sde[i][0], _mm_unpacklo_ps(vec_a, vec_b));
       _mm_storeu_ps(&aec->sde[i + 2][0], _mm_unpackhi_ps(vec_a, vec_b));
     }
 
     {
       const __m128 vec_3210 = _mm_loadu_ps(&aec->sxd[i][0]);
       const __m128 vec_7654 = _mm_loadu_ps(&aec->sxd[i + 2][0]);
-      __m128 vec_a = _mm_shuffle_ps(vec_3210, vec_7654,
-                                    _MM_SHUFFLE(2, 0, 2, 0));
-      __m128 vec_b = _mm_shuffle_ps(vec_3210, vec_7654,
-                                    _MM_SHUFFLE(3, 1, 3, 1));
+      __m128 vec_a =
+          _mm_shuffle_ps(vec_3210, vec_7654, _MM_SHUFFLE(2, 0, 2, 0));
+      __m128 vec_b =
+          _mm_shuffle_ps(vec_3210, vec_7654, _MM_SHUFFLE(3, 1, 3, 1));
       __m128 vec_dfwxfw0011 = _mm_mul_ps(vec_dfw0, vec_xfw0);
       __m128 vec_dfwxfw0110 = _mm_mul_ps(vec_dfw0, vec_xfw1);
       vec_a = _mm_mul_ps(vec_a, vec_GCoh0);
       vec_b = _mm_mul_ps(vec_b, vec_GCoh0);
-      vec_dfwxfw0011 = _mm_add_ps(vec_dfwxfw0011,
-                                  _mm_mul_ps(vec_dfw1, vec_xfw1));
-      vec_dfwxfw0110 = _mm_sub_ps(vec_dfwxfw0110,
-                                  _mm_mul_ps(vec_dfw1, vec_xfw0));
+      vec_dfwxfw0011 =
+          _mm_add_ps(vec_dfwxfw0011, _mm_mul_ps(vec_dfw1, vec_xfw1));
+      vec_dfwxfw0110 =
+          _mm_sub_ps(vec_dfwxfw0110, _mm_mul_ps(vec_dfw1, vec_xfw0));
       vec_a = _mm_add_ps(vec_a, _mm_mul_ps(vec_dfwxfw0011, vec_GCoh1));
       vec_b = _mm_add_ps(vec_b, _mm_mul_ps(vec_dfwxfw0110, vec_GCoh1));
       _mm_storeu_ps(&aec->sxd[i][0], _mm_unpacklo_ps(vec_a, vec_b));
       _mm_storeu_ps(&aec->sxd[i + 2][0], _mm_unpackhi_ps(vec_a, vec_b));
     }
 
     vec_sdSum = _mm_add_ps(vec_sdSum, vec_sd);
     vec_seSum = _mm_add_ps(vec_seSum, vec_se);
   }
 
   _mm_add_ps_4x1(vec_sdSum, &sdSum);
   _mm_add_ps_4x1(vec_seSum, &seSum);
 
   for (; 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 18 matching lines @@
 static void WindowDataSSE2(float* x_windowed, const float* x) {
   int i;
   for (i = 0; i < PART_LEN; i += 4) {
     const __m128 vec_Buf1 = _mm_loadu_ps(&x[i]);
     const __m128 vec_Buf2 = _mm_loadu_ps(&x[PART_LEN + i]);
     const __m128 vec_sqrtHanning = _mm_load_ps(&WebRtcAec_sqrtHanning[i]);
     // A B C D
     __m128 vec_sqrtHanning_rev =
         _mm_loadu_ps(&WebRtcAec_sqrtHanning[PART_LEN - i - 3]);
     // D C B A
-    vec_sqrtHanning_rev =
-        _mm_shuffle_ps(vec_sqrtHanning_rev, vec_sqrtHanning_rev,
-                       _MM_SHUFFLE(0, 1, 2, 3));
+    vec_sqrtHanning_rev = _mm_shuffle_ps(
+        vec_sqrtHanning_rev, vec_sqrtHanning_rev, _MM_SHUFFLE(0, 1, 2, 3));
     _mm_storeu_ps(&x_windowed[i], _mm_mul_ps(vec_Buf1, vec_sqrtHanning));
     _mm_storeu_ps(&x_windowed[PART_LEN + i],
                   _mm_mul_ps(vec_Buf2, vec_sqrtHanning_rev));
   }
 }
 
 // Puts fft output data into a complex valued array.
 static void StoreAsComplexSSE2(const float* data,
                                float data_complex[2][PART_LEN1]) {
   int i;
   for (i = 0; i < PART_LEN; i += 4) {
     const __m128 vec_fft0 = _mm_loadu_ps(&data[2 * i]);
     const __m128 vec_fft4 = _mm_loadu_ps(&data[2 * i + 4]);
-    const __m128 vec_a = _mm_shuffle_ps(vec_fft0, vec_fft4,
-                                        _MM_SHUFFLE(2, 0, 2, 0));
-    const __m128 vec_b = _mm_shuffle_ps(vec_fft0, vec_fft4,
-                                        _MM_SHUFFLE(3, 1, 3, 1));
+    const __m128 vec_a =
+        _mm_shuffle_ps(vec_fft0, vec_fft4, _MM_SHUFFLE(2, 0, 2, 0));
+    const __m128 vec_b =
+        _mm_shuffle_ps(vec_fft0, vec_fft4, _MM_SHUFFLE(3, 1, 3, 1));
     _mm_storeu_ps(&data_complex[0][i], vec_a);
     _mm_storeu_ps(&data_complex[1][i], vec_b);
   }
   // fix beginning/end values
   data_complex[1][0] = 0;
   data_complex[1][PART_LEN] = 0;
   data_complex[0][0] = data[0];
   data_complex[0][PART_LEN] = data[1];
 }
 
 static void SubbandCoherenceSSE2(AecCore* aec,
                                  float efw[2][PART_LEN1],
                                  float dfw[2][PART_LEN1],
                                  float xfw[2][PART_LEN1],
                                  float* fft,
                                  float* cohde,
                                  float* cohxd,
                                  int* extreme_filter_divergence) {
   int i;
 
   SmoothedPSD(aec, efw, dfw, xfw, extreme_filter_divergence);
 
   {
-    const __m128 vec_1eminus10 =  _mm_set1_ps(1e-10f);
+    const __m128 vec_1eminus10 = _mm_set1_ps(1e-10f);
 
     // Subband coherence
     for (i = 0; i + 3 < PART_LEN1; i += 4) {
       const __m128 vec_sd = _mm_loadu_ps(&aec->sd[i]);
       const __m128 vec_se = _mm_loadu_ps(&aec->se[i]);
       const __m128 vec_sx = _mm_loadu_ps(&aec->sx[i]);
-      const __m128 vec_sdse = _mm_add_ps(vec_1eminus10,
-                                         _mm_mul_ps(vec_sd, vec_se));
-      const __m128 vec_sdsx = _mm_add_ps(vec_1eminus10,
-                                         _mm_mul_ps(vec_sd, vec_sx));
+      const __m128 vec_sdse =
+          _mm_add_ps(vec_1eminus10, _mm_mul_ps(vec_sd, vec_se));
+      const __m128 vec_sdsx =
+          _mm_add_ps(vec_1eminus10, _mm_mul_ps(vec_sd, vec_sx));
       const __m128 vec_sde_3210 = _mm_loadu_ps(&aec->sde[i][0]);
       const __m128 vec_sde_7654 = _mm_loadu_ps(&aec->sde[i + 2][0]);
       const __m128 vec_sxd_3210 = _mm_loadu_ps(&aec->sxd[i][0]);
       const __m128 vec_sxd_7654 = _mm_loadu_ps(&aec->sxd[i + 2][0]);
-      const __m128 vec_sde_0 = _mm_shuffle_ps(vec_sde_3210, vec_sde_7654,
-                                              _MM_SHUFFLE(2, 0, 2, 0));
-      const __m128 vec_sde_1 = _mm_shuffle_ps(vec_sde_3210, vec_sde_7654,
-                                              _MM_SHUFFLE(3, 1, 3, 1));
-      const __m128 vec_sxd_0 = _mm_shuffle_ps(vec_sxd_3210, vec_sxd_7654,
-                                              _MM_SHUFFLE(2, 0, 2, 0));
-      const __m128 vec_sxd_1 = _mm_shuffle_ps(vec_sxd_3210, vec_sxd_7654,
-                                              _MM_SHUFFLE(3, 1, 3, 1));
+      const __m128 vec_sde_0 =
+          _mm_shuffle_ps(vec_sde_3210, vec_sde_7654, _MM_SHUFFLE(2, 0, 2, 0));
+      const __m128 vec_sde_1 =
+          _mm_shuffle_ps(vec_sde_3210, vec_sde_7654, _MM_SHUFFLE(3, 1, 3, 1));
+      const __m128 vec_sxd_0 =
+          _mm_shuffle_ps(vec_sxd_3210, vec_sxd_7654, _MM_SHUFFLE(2, 0, 2, 0));
+      const __m128 vec_sxd_1 =
+          _mm_shuffle_ps(vec_sxd_3210, vec_sxd_7654, _MM_SHUFFLE(3, 1, 3, 1));
       __m128 vec_cohde = _mm_mul_ps(vec_sde_0, vec_sde_0);
       __m128 vec_cohxd = _mm_mul_ps(vec_sxd_0, vec_sxd_0);
       vec_cohde = _mm_add_ps(vec_cohde, _mm_mul_ps(vec_sde_1, vec_sde_1));
       vec_cohde = _mm_div_ps(vec_cohde, vec_sdse);
       vec_cohxd = _mm_add_ps(vec_cohxd, _mm_mul_ps(vec_sxd_1, vec_sxd_1));
       vec_cohxd = _mm_div_ps(vec_cohxd, vec_sdsx);
       _mm_storeu_ps(&cohde[i], vec_cohde);
       _mm_storeu_ps(&cohxd[i], vec_cohxd);
     }
 
@@ skipping 12 matching lines @@
 void WebRtcAec_InitAec_SSE2(void) {
   WebRtcAec_FilterFar = FilterFarSSE2;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignalSSE2;
   WebRtcAec_FilterAdaptation = FilterAdaptationSSE2;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppressSSE2;
   WebRtcAec_SubbandCoherence = SubbandCoherenceSSE2;
   WebRtcAec_StoreAsComplex = StoreAsComplexSSE2;
   WebRtcAec_PartitionDelay = PartitionDelaySSE2;
   WebRtcAec_WindowData = WindowDataSSE2;
 }