Match existing type usage better.

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 209 matching lines @@
     DspHelper::CrossFade(voiced_vector, unvoiced_vector, temp_lenght,
                          &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 (mix_factor_increment != 0) {
         parameters.current_voice_mix_factor = parameters.voice_mix_factor;
       }
-      int temp_scale = 16384 - parameters.current_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));
     }
 
     // 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.
@@ skipping 423 matching lines @@
                                                             128,
                                                             unvoiced_prescale);
 
     // Normalize |unvoiced_energy| to 28 or 29 bits to preserve sqrt() accuracy.
     int16_t unvoiced_scale = WebRtcSpl_NormW32(unvoiced_energy) - 3;
     // Make sure we do an odd number of shifts since we already have 7 shifts
     // from dividing with 128 earlier. This will make the total scale factor
     // even, which is suitable for the sqrt.
     unvoiced_scale += ((unvoiced_scale & 0x1) ^ 0x1);
     unvoiced_energy = WEBRTC_SPL_SHIFT_W32(unvoiced_energy, unvoiced_scale);
-    int32_t unvoiced_gain = WebRtcSpl_SqrtFloor(unvoiced_energy);
+    int16_t unvoiced_gain =
+        static_cast<int16_t>(WebRtcSpl_SqrtFloor(unvoiced_energy));
     parameters.ar_gain_scale = 13
         + (unvoiced_scale + 7 - unvoiced_prescale) / 2;
     parameters.ar_gain = unvoiced_gain;
 
     // Calculate voice_mix_factor from corr_coefficient.
     // Let x = corr_coefficient. Then, we compute:
     // if (x > 0.48)
     //   voice_mix_factor = (-5179 + 19931x - 16422x^2 + 5776x^3) / 4096;
     // else
     //   voice_mix_factor = 0;
@@ skipping 20 matching lines @@
     // |expand_vector0| and |expand_vector1|.
     int16_t slope = amplitude_ratio;
     if (slope > 12288) {
       // slope > 1.5.
       // Calculate (1 - (1 / slope)) / distortion_lag =
       // (slope - 1) / (distortion_lag * slope).
       // |slope| is in Q13, so 1 corresponds to 8192. Shift up to Q25 before
       // the division.
       // Shift the denominator from Q13 to Q5 before the division. The result of
       // the division will then be in Q20.
-      int16_t temp_ratio = WebRtcSpl_DivW32W16((slope - 8192) << 12,
-                                               (distortion_lag * slope) >> 8);
+      int16_t temp_ratio = WebRtcSpl_DivW32W16(
+          (slope - 8192) << 12,
+          static_cast<int16_t>((distortion_lag * slope) >> 8));
       if (slope > 14746) {
         // slope > 1.8.
         // Divide by 2, with proper rounding.
         parameters.mute_slope = (temp_ratio + 1) / 2;
       } else {
         // Divide by 8, with proper rounding.
         parameters.mute_slope = (temp_ratio + 4) / 8;
       }
       parameters.onset = true;
     } else {
       // Calculate (1 - slope) / distortion_lag.
       // Shift |slope| by 7 to Q20 before the division. The result is in Q20.
-      parameters.mute_slope = WebRtcSpl_DivW32W16((8192 - slope) << 7,
-                                                   distortion_lag);
+      parameters.mute_slope = WebRtcSpl_DivW32W16(
+          (8192 - slope) << 7, static_cast<int16_t>(distortion_lag));
       if (parameters.voice_mix_factor <= 13107) {
         // Make sure the mute factor decreases from 1.0 to 0.9 in no more than
         // 6.25 ms.
         // mute_slope >= 0.005 / fs_mult in Q20.
         parameters.mute_slope = std::max(static_cast<int16_t>(5243 / fs_mult),
                                          parameters.mute_slope);
       } else if (slope > 8028) {
         parameters.mute_slope = 0;
       }
       parameters.onset = false;
@@ skipping 65 matching lines @@
   WebRtcSpl_CrossCorrelation(
       correlation,
       &downsampled_input[kDownsampledLength - kCorrelationLength],
       &downsampled_input[kDownsampledLength - kCorrelationLength
           - kCorrelationStartLag],
       kCorrelationLength, kNumCorrelationLags, kCorrelationShift, -1);
 
   // Normalize and move data from 32-bit to 16-bit vector.
   int32_t max_correlation = WebRtcSpl_MaxAbsValueW32(correlation,
                                                      kNumCorrelationLags);
-  int16_t norm_shift2 = std::max(18 - WebRtcSpl_NormW32(max_correlation), 0);
+  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.
@@ skipping 97 matching lines @@
       }
     }
     // Update mute_factor in BackgroundNoise class.
     background_noise_->SetMuteFactor(channel, bgn_mute_factor);
   } else {
     // BGN parameters have not been initialized; use zero noise.
     memset(noise_samples, 0, sizeof(int16_t) * num_noise_samples);
   }
 }
 
-void Expand::GenerateRandomVector(int seed_increment,
+void Expand::GenerateRandomVector(int16_t seed_increment,
                                   size_t length,
                                   int16_t* random_vector) {
   // TODO(turajs): According to hlundin The loop should not be needed. Should be
   // just as good to generate all of the vector in one call.
   size_t samples_generated = 0;
   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