Clang format changes

webrtc/modules/audio_processing/aec/echo_cancellation.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 169 matching lines @@
 
   WebRtcAec_FreeAec(aecpc->aec);
   WebRtcAec_FreeResampler(aecpc->resampler);
   free(aecpc);
 }
 
 int32_t WebRtcAec_Init(void* aecInst, int32_t sampFreq, int32_t scSampFreq) {
   Aec* aecpc = aecInst;
   AecConfig aecConfig;
 
-  if (sampFreq != 8000 &&
-      sampFreq != 16000 &&
-      sampFreq != 32000 &&
+  if (sampFreq != 8000 && sampFreq != 16000 && sampFreq != 32000 &&
       sampFreq != 48000) {
     return AEC_BAD_PARAMETER_ERROR;
   }
   aecpc->sampFreq = sampFreq;
 
   if (scSampFreq < 1 || scSampFreq > 96000) {
     return AEC_BAD_PARAMETER_ERROR;
   }
   aecpc->scSampFreq = scSampFreq;
 
@@ skipping 23 matching lines @@
   aecpc->rate_factor = aecpc->splitSampFreq / 8000;
 
   aecpc->sum = 0;
   aecpc->counter = 0;
   aecpc->checkBuffSize = 1;
   aecpc->firstVal = 0;
 
   // We skip the startup_phase completely (setting to 0) if DA-AEC is enabled,
   // but not extended_filter mode.
   aecpc->startup_phase = WebRtcAec_extended_filter_enabled(aecpc->aec) ||
-      !WebRtcAec_delay_agnostic_enabled(aecpc->aec);
+                         !WebRtcAec_delay_agnostic_enabled(aecpc->aec);
   aecpc->bufSizeStart = 0;
   aecpc->checkBufSizeCtr = 0;
   aecpc->msInSndCardBuf = 0;
   aecpc->filtDelay = -1;  // -1 indicates an initialized state.
   aecpc->timeForDelayChange = 0;
   aecpc->knownDelay = 0;
   aecpc->lastDelayDiff = 0;
 
   aecpc->skewFrCtr = 0;
   aecpc->resample = kAecFalse;
@@ skipping 38 matching lines @@
 // only buffer L band for farend
 int32_t WebRtcAec_BufferFarend(void* aecInst,
                                const float* farend,
                                size_t nrOfSamples) {
   Aec* aecpc = aecInst;
   size_t newNrOfSamples = nrOfSamples;
   float new_farend[MAX_RESAMP_LEN];
   const float* farend_ptr = farend;
 
   // Get any error caused by buffering the farend signal.
-  int32_t error_code = WebRtcAec_GetBufferFarendError(aecInst, farend,
-                                                      nrOfSamples);
+  int32_t error_code =
+      WebRtcAec_GetBufferFarendError(aecInst, farend, nrOfSamples);
 
   if (error_code != 0)
     return error_code;
 
-
   if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
     // Resample and get a new number of samples
-    WebRtcAec_ResampleLinear(aecpc->resampler,
-                             farend,
-                             nrOfSamples,
-                             aecpc->skew,
-                             new_farend,
-                             &newNrOfSamples);
+    WebRtcAec_ResampleLinear(aecpc->resampler, farend, nrOfSamples, aecpc->skew,
+                             new_farend, &newNrOfSamples);
     farend_ptr = new_farend;
   }
 
   aecpc->farend_started = 1;
   WebRtcAec_SetSystemDelay(
       aecpc->aec, WebRtcAec_system_delay(aecpc->aec) + (int)newNrOfSamples);
 
   // Write the time-domain data to |far_pre_buf|.
   WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, newNrOfSamples);
 
@@ skipping 41 matching lines @@
   if (msInSndCardBuf < 0) {
     msInSndCardBuf = 0;
     retVal = AEC_BAD_PARAMETER_WARNING;
   } else if (msInSndCardBuf > kMaxTrustedDelayMs) {
     // The clamping is now done in ProcessExtended/Normal().
     retVal = AEC_BAD_PARAMETER_WARNING;
   }
 
   // This returns the value of aec->extended_filter_enabled.
   if (WebRtcAec_extended_filter_enabled(aecpc->aec)) {
-    ProcessExtended(aecpc,
-                    nearend,
-                    num_bands,
-                    out,
-                    nrOfSamples,
-                    msInSndCardBuf,
+    ProcessExtended(aecpc, nearend, num_bands, out, nrOfSamples, msInSndCardBuf,
                     skew);
   } else {
-    retVal = ProcessNormal(aecpc,
-                           nearend,
-                           num_bands,
-                           out,
-                           nrOfSamples,
-                           msInSndCardBuf,
-                           skew);
+    retVal = ProcessNormal(aecpc, nearend, num_bands, out, nrOfSamples,
+                           msInSndCardBuf, skew);
   }
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     int16_t far_buf_size_ms = (int16_t)(WebRtcAec_system_delay(aecpc->aec) /
                                         (sampMsNb * aecpc->rate_factor));
     (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile);
-    (void)fwrite(
-        &aecpc->knownDelay, sizeof(aecpc->knownDelay), 1, aecpc->delayFile);
+    (void)fwrite(&aecpc->knownDelay, sizeof(aecpc->knownDelay), 1,
+                 aecpc->delayFile);
   }
 #endif
 
   return retVal;
 }
 
 int WebRtcAec_set_config(void* handle, AecConfig config) {
   Aec* self = (Aec*)handle;
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
@@ skipping 11 matching lines @@
   }
 
   if (config.metricsMode != kAecFalse && config.metricsMode != kAecTrue) {
     return AEC_BAD_PARAMETER_ERROR;
   }
 
   if (config.delay_logging != kAecFalse && config.delay_logging != kAecTrue) {
     return AEC_BAD_PARAMETER_ERROR;
   }
 
-  WebRtcAec_SetConfigCore(
-      self->aec, config.nlpMode, config.metricsMode, config.delay_logging);
+  WebRtcAec_SetConfigCore(self->aec, config.nlpMode, config.metricsMode,
+                          config.delay_logging);
   return 0;
 }
 
 int WebRtcAec_get_echo_status(void* handle, int* status) {
   Aec* self = (Aec*)handle;
   if (status == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
@@ skipping 107 matching lines @@
   if (median == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (std == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
   if (WebRtcAec_GetDelayMetricsCore(self->aec, median, std,
-                                    fraction_poor_delays) ==
-      -1) {
+                                    fraction_poor_delays) == -1) {
     // Logging disabled.
     return AEC_UNSUPPORTED_FUNCTION_ERROR;
   }
 
   return 0;
 }
 
-
 AecCore* WebRtcAec_aec_core(void* handle) {
   if (!handle) {
     return NULL;
   }
   return ((Aec*)handle)->aec;
 }
 
 static int ProcessNormal(Aec* aecpc,
                          const float* const* nearend,
                          size_t num_bands,
@@ skipping 124 matching lines @@
       }
     }
   } else {
     // AEC is enabled.
     EstBufDelayNormal(aecpc);
 
     // Call the AEC.
     // TODO(bjornv): Re-structure such that we don't have to pass
     // |aecpc->knownDelay| as input. Change name to something like
     // |system_buffer_diff|.
-    WebRtcAec_ProcessFrames(aecpc->aec,
-                            nearend,
-                            num_bands,
-                            nrOfSamples,
-                            aecpc->knownDelay,
-                            out);
+    WebRtcAec_ProcessFrames(aecpc->aec, nearend, num_bands, nrOfSamples,
+                            aecpc->knownDelay, out);
   }
 
   return retVal;
 }
 
 static void ProcessExtended(Aec* self,
                             const float* const* near,
                             size_t num_bands,
                             float* const* out,
                             size_t num_samples,
@@ skipping 53 matching lines @@
 
   EstBufDelayExtended(self);
 
   {
     // |delay_diff_offset| gives us the option to manually rewind the delay on
     // very low delay platforms which can't be expressed purely through
     // |reported_delay_ms|.
     const int adjusted_known_delay =
         WEBRTC_SPL_MAX(0, self->knownDelay + delay_diff_offset);
 
-    WebRtcAec_ProcessFrames(self->aec,
-                            near,
-                            num_bands,
-                            num_samples,
-                            adjusted_known_delay,
-                            out);
+    WebRtcAec_ProcessFrames(self->aec, near, num_bands, num_samples,
+                            adjusted_known_delay, out);
   }
 }
 
 static void EstBufDelayNormal(Aec* aecpc) {
   int nSampSndCard = aecpc->msInSndCardBuf * sampMsNb * aecpc->rate_factor;
   int current_delay = nSampSndCard - WebRtcAec_system_delay(aecpc->aec);
   int delay_difference = 0;
 
   // Before we proceed with the delay estimate filtering we:
   // 1) Compensate for the frame that will be read.
@@ skipping 89 matching lines @@
     }
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }