Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/background_noise.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.
  */
 
 #include "webrtc/modules/audio_coding/neteq/background_noise.h"
 
 #include <assert.h>
 #include <string.h>  // memcpy
 
 #include <algorithm>  // min, max
 
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/neteq/audio_multi_vector.h"
 #include "webrtc/modules/audio_coding/neteq/post_decode_vad.h"
 
 namespace webrtc {
 
+// static
+const size_t BackgroundNoise::kMaxLpcOrder;
+
 BackgroundNoise::BackgroundNoise(size_t num_channels)
     : num_channels_(num_channels),
       channel_parameters_(new ChannelParameters[num_channels_]),
       mode_(NetEq::kBgnOn) {
   Reset();
 }
 
 BackgroundNoise::~BackgroundNoise() {}
 
 void BackgroundNoise::Reset() {
@@ skipping 109 matching lines @@
 }
 
 const int16_t* BackgroundNoise::FilterState(size_t channel) const {
   assert(channel < num_channels_);
   return channel_parameters_[channel].filter_state;
 }
 
 void BackgroundNoise::SetFilterState(size_t channel, const int16_t* input,
                                      size_t length) {
   assert(channel < num_channels_);
-  length = std::min(length, static_cast<size_t>(kMaxLpcOrder));
+  length = std::min(length, kMaxLpcOrder);
   memcpy(channel_parameters_[channel].filter_state, input,
          length * sizeof(int16_t));
 }
 
 int16_t BackgroundNoise::Scale(size_t channel) const {
   assert(channel < num_channels_);
   return channel_parameters_[channel].scale;
 }
 int16_t BackgroundNoise::ScaleShift(size_t channel) const {
   assert(channel < num_channels_);
   return channel_parameters_[channel].scale_shift;
 }
 
 int32_t BackgroundNoise::CalculateAutoCorrelation(
-    const int16_t* signal, int length, int32_t* auto_correlation) const {
+    const int16_t* signal, size_t length, int32_t* auto_correlation) const {
   int16_t signal_max = WebRtcSpl_MaxAbsValueW16(signal, length);
   int correlation_scale = kLogVecLen -
       WebRtcSpl_NormW32(signal_max * signal_max);
   correlation_scale = std::max(0, correlation_scale);
 
   static const int kCorrelationStep = -1;
   WebRtcSpl_CrossCorrelation(auto_correlation, signal, signal, length,
                              kMaxLpcOrder + 1, correlation_scale,
                              kCorrelationStep);
 
@@ skipping 61 matching lines @@
 
   // Normalize residual_energy to 29 or 30 bits before sqrt.
   int16_t norm_shift = WebRtcSpl_NormW32(residual_energy) - 1;
   if (norm_shift & 0x1) {
     norm_shift -= 1;  // Even number of shifts required.
   }
   assert(norm_shift >= 0);  // Should always be positive.
   residual_energy = residual_energy << norm_shift;
 
   // Calculate scale and shift factor.
-  parameters.scale = WebRtcSpl_SqrtFloor(residual_energy);
+  parameters.scale = static_cast<int16_t>(WebRtcSpl_SqrtFloor(residual_energy));
   // Add 13 to the |scale_shift_|, since the random numbers table is in
   // Q13.
   // TODO(hlundin): Move the "13" to where the |scale_shift_| is used?
   parameters.scale_shift =
       static_cast<int16_t>(13 + ((kLogResidualLength + norm_shift) / 2));
 
   initialized_ = true;
 }
 
 }  // namespace webrtc