Reformat existing code. There should be no functional effects.

webrtc/modules/audio_coding/neteq/expand.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 196 matching lines @@
     //   >= 64 * fs_mult            => go from 1 to 0 in about 32 ms.
     // temp_shift = getbits(max_lag_) - 5.
     int temp_shift = (31 - WebRtcSpl_NormW32(max_lag_)) - 5;
     int16_t mix_factor_increment = 256 >> temp_shift;
     if (stop_muting_) {
       mix_factor_increment = 0;
     }
 
     // Create combined signal by shifting in more and more of unvoiced part.
     temp_shift = 8 - temp_shift;  // = getbits(mix_factor_increment).
-    size_t temp_lenght = (parameters.current_voice_mix_factor -
+    size_t temp_length = (parameters.current_voice_mix_factor -
         parameters.voice_mix_factor) >> temp_shift;
-    temp_lenght = std::min(temp_lenght, current_lag);
-    DspHelper::CrossFade(voiced_vector, unvoiced_vector, temp_lenght,
+    temp_length = std::min(temp_length, current_lag);
+    DspHelper::CrossFade(voiced_vector, unvoiced_vector, temp_length,
                          &parameters.current_voice_mix_factor,
                          mix_factor_increment, temp_data);
 
     // End of cross-fading period was reached before end of expanded signal
     // path. Mix the rest with a fixed mixing factor.
-    if (temp_lenght < current_lag) {
+    if (temp_length < current_lag) {
       if (mix_factor_increment != 0) {
         parameters.current_voice_mix_factor = parameters.voice_mix_factor;
       }
       int16_t temp_scale = 16384 - parameters.current_voice_mix_factor;
       WebRtcSpl_ScaleAndAddVectorsWithRound(
-          voiced_vector + temp_lenght, parameters.current_voice_mix_factor,
-          unvoiced_vector + temp_lenght, temp_scale, 14,
-          temp_data + temp_lenght, static_cast<int>(current_lag - temp_lenght));
+          voiced_vector + temp_length, parameters.current_voice_mix_factor,
+          unvoiced_vector + temp_length, temp_scale, 14,
+          temp_data + temp_length, static_cast<int>(current_lag - temp_length));
     }
 
     // Select muting slope depending on how many consecutive expands we have
     // done.
     if (consecutive_expands_ == 3) {
       // Let the mute factor decrease from 1.0 to 0.95 in 6.25 ms.
       // mute_slope = 0.0010 / fs_mult in Q20.
       parameters.mute_slope = std::max(parameters.mute_slope,
                                        static_cast<int16_t>(1049 / fs_mult));
     }
@@ skipping 176 matching lines @@
       best_ratio = ratio;
     }
   }
 
   int distortion_lag = best_distortion_index[best_index];
   int correlation_lag = best_correlation_index[best_index];
   max_lag_ = std::max(distortion_lag, correlation_lag);
 
   // Calculate the exact best correlation in the range between
   // |correlation_lag| and |distortion_lag|.
-  correlation_length = distortion_lag + 10;
-  correlation_length = std::min(correlation_length, fs_mult_120);
-  correlation_length = std::max(correlation_length, 60 * fs_mult);
+  correlation_length =
+      std::max(std::min(distortion_lag + 10, fs_mult_120), 60 * fs_mult);
 
   int start_index = std::min(distortion_lag, correlation_lag);
-  int correlation_lags = WEBRTC_SPL_ABS_W16((distortion_lag-correlation_lag))
-      + 1;
+  int correlation_lags =
+      WEBRTC_SPL_ABS_W16((distortion_lag-correlation_lag)) + 1;
   assert(correlation_lags <= 99 * fs_mult + 1);  // Cannot be larger.
 
   for (size_t channel_ix = 0; channel_ix < num_channels_; ++channel_ix) {
     ChannelParameters& parameters = channel_parameters_[channel_ix];
     // Calculate suitable scaling.
     int16_t signal_max = WebRtcSpl_MaxAbsValueW16(
         &audio_history[signal_length - correlation_length - start_index
                        - correlation_lags],
                        correlation_length + start_index + correlation_lags - 1);
     correlation_scale = ((31 - WebRtcSpl_NormW32(signal_max * signal_max))
@@ skipping 298 matching lines @@
       ar_gain(0),
       ar_gain_scale(0),
       voice_mix_factor(0),
       current_voice_mix_factor(0),
       onset(false),
       mute_slope(0) {
   memset(ar_filter, 0, sizeof(ar_filter));
   memset(ar_filter_state, 0, sizeof(ar_filter_state));
 }
 
-int16_t Expand::Correlation(const int16_t* input, size_t input_length,
-                            int16_t* output, int16_t* output_scale) const {
+void Expand::Correlation(const int16_t* input,
+                         size_t input_length,
+                         int16_t* output,
+                         int16_t* output_scale) const {
   // Set parameters depending on sample rate.
   const int16_t* filter_coefficients;
   int16_t num_coefficients;
   int16_t downsampling_factor;
   if (fs_hz_ == 8000) {
     num_coefficients = 3;
     downsampling_factor = 2;
     filter_coefficients = DspHelper::kDownsample8kHzTbl;
   } else if (fs_hz_ == 16000) {
     num_coefficients = 5;
@@ skipping 43 matching lines @@
 
   // Normalize and move data from 32-bit to 16-bit vector.
   int32_t max_correlation = WebRtcSpl_MaxAbsValueW32(correlation,
                                                      kNumCorrelationLags);
   int16_t norm_shift2 = static_cast<int16_t>(
       std::max(18 - WebRtcSpl_NormW32(max_correlation), 0));
   WebRtcSpl_VectorBitShiftW32ToW16(output, kNumCorrelationLags, correlation,
                                    norm_shift2);
   // Total scale factor (right shifts) of correlation value.
   *output_scale = 2 * norm_shift + kCorrelationShift + norm_shift2;
-  return kNumCorrelationLags;
 }
 
 void Expand::UpdateLagIndex() {
   current_lag_index_ = current_lag_index_ + lag_index_direction_;
   // Change direction if needed.
   if (current_lag_index_ <= 0) {
     lag_index_direction_ = 1;
   }
   if (current_lag_index_ >= kNumLags - 1) {
     lag_index_direction_ = -1;
@@ skipping 11 matching lines @@
 
 // TODO(turajs): This can be moved to BackgroundNoise class.
 void Expand::GenerateBackgroundNoise(int16_t* random_vector,
                                      size_t channel,
                                      int16_t mute_slope,
                                      bool too_many_expands,
                                      size_t num_noise_samples,
                                      int16_t* buffer) {
   static const int kNoiseLpcOrder = BackgroundNoise::kMaxLpcOrder;
   int16_t scaled_random_vector[kMaxSampleRate / 8000 * 125];
-  assert(static_cast<size_t>(kMaxSampleRate / 8000 * 125) >= num_noise_samples);
+  assert(num_noise_samples <= static_cast<size_t>(kMaxSampleRate / 8000 * 125));
   int16_t* noise_samples = &buffer[kNoiseLpcOrder];
   if (background_noise_->initialized()) {
     // Use background noise parameters.
     memcpy(noise_samples - kNoiseLpcOrder,
            background_noise_->FilterState(channel),
            sizeof(int16_t) * kNoiseLpcOrder);
 
     int dc_offset = 0;
     if (background_noise_->ScaleShift(channel) > 1) {
       dc_offset = 1 << (background_noise_->ScaleShift(channel) - 1);
@@ skipping 76 matching lines @@
   const size_t kMaxRandSamples = RandomVector::kRandomTableSize;
   while (samples_generated < length) {
     size_t rand_length = std::min(length - samples_generated, kMaxRandSamples);
     random_vector_->IncreaseSeedIncrement(seed_increment);
     random_vector_->Generate(rand_length, &random_vector[samples_generated]);
     samples_generated += rand_length;
   }
 }
 
 }  // namespace webrtc