Prepare to convert various types to size_t.

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 386 matching lines @@
     distortion_scale = std::max(16 - WebRtcSpl_NormW32(best_distortion_w32[i]),
                                 distortion_scale);
   }
   // Shift the distortion values to fit in 16 bits.
   WebRtcSpl_VectorBitShiftW32ToW16(best_distortion, kNumCorrelationCandidates,
                                    best_distortion_w32, distortion_scale);
 
   // Find the maximizing index |i| of the cost function
   // f[i] = best_correlation[i] / best_distortion[i].
   int32_t best_ratio = std::numeric_limits<int32_t>::min();
-  int best_index = -1;
+  int best_index = std::numeric_limits<int>::max();
   for (int i = 0; i < kNumCorrelationCandidates; ++i) {
     int32_t ratio;
     if (best_distortion[i] > 0) {
       ratio = (best_correlation[i] << 16) / best_distortion[i];
     } else if (best_correlation[i] == 0) {
       ratio = 0;  // No correlation set result to zero.
     } else {
       ratio = std::numeric_limits<int32_t>::max();  // Denominator is zero.
     }
     if (ratio > best_ratio) {
@@ skipping 124 matching lines @@
       parameters.expand_vector0.CopyTo(&parameters.expand_vector1);
       // Set the energy_ratio since it is used by muting slope.
       if ((energy1 / 4 < energy2) || (energy2 == 0)) {
         amplitude_ratio = 4096;  // 0.5 in Q13.
       } else {
         amplitude_ratio = 16384;  // 2.0 in Q13.
       }
     }
 
     // Set the 3 lag values.
-    int lag_difference = distortion_lag - correlation_lag;
-    if (lag_difference == 0) {
-      // |distortion_lag| and |correlation_lag| are equal.
+    if (distortion_lag == correlation_lag) {
       expand_lags_[0] = distortion_lag;
       expand_lags_[1] = distortion_lag;
       expand_lags_[2] = distortion_lag;
     } else {
       // |distortion_lag| and |correlation_lag| are not equal; use different
       // combinations of the two.
       // First lag is |distortion_lag| only.
       expand_lags_[0] = distortion_lag;
       // Second lag is the average of the two.
       expand_lags_[1] = (distortion_lag + correlation_lag) / 2;
       // Third lag is the average again, but rounding towards |correlation_lag|.
-      if (lag_difference > 0) {
+      if (distortion_lag > correlation_lag) {
         expand_lags_[2] = (distortion_lag + correlation_lag - 1) / 2;
       } else {
         expand_lags_[2] = (distortion_lag + correlation_lag + 1) / 2;
       }
     }
 
     // Calculate the LPC and the gain of the filters.
     // Calculate scale value needed for auto-correlation.
     correlation_scale = WebRtcSpl_MaxAbsValueW16(
         &(audio_history[signal_length - fs_mult_lpc_analysis_len]),
@@ skipping 107 matching lines @@
       int16_t x1, x2, x3;
       // |corr_coefficient| is in Q14.
       x1 = static_cast<int16_t>(corr_coefficient);
       x2 = (x1 * x1) >> 14;   // Shift 14 to keep result in Q14.
       x3 = (x1 * x2) >> 14;
       static const int kCoefficients[4] = { -5179, 19931, -16422, 5776 };
       int32_t temp_sum = kCoefficients[0] << 14;
       temp_sum += kCoefficients[1] * x1;
       temp_sum += kCoefficients[2] * x2;
       temp_sum += kCoefficients[3] * x3;
-      parameters.voice_mix_factor = temp_sum / 4096;
-      parameters.voice_mix_factor = std::min(parameters.voice_mix_factor,
-                                             static_cast<int16_t>(16384));
+      parameters.voice_mix_factor =
+          static_cast<int16_t>(std::min(temp_sum / 4096, 16384));
       parameters.voice_mix_factor = std::max(parameters.voice_mix_factor,
                                              static_cast<int16_t>(0));
     } else {
       parameters.voice_mix_factor = 0;
     }
 
     // Calculate muting slope. Reuse value from earlier scaling of
     // |expand_vector0| and |expand_vector1|.
     int16_t slope = amplitude_ratio;
     if (slope > 12288) {
@@ skipping 231 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