Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/normal.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 27 matching lines @@
   assert(output->Empty());
   // Output should be empty at this point.
   if (length % output->Channels() != 0) {
     // The length does not match the number of channels.
     output->Clear();
     return 0;
   }
   output->PushBackInterleaved(input, length);
   int16_t* signal = &(*output)[0][0];
 
-  const unsigned fs_mult = fs_hz_ / 8000;
+  const size_t fs_mult = fs_hz_ / 8000;

[hlundin-webrtc, 2015/08/10 11:30:01]

not size_t

   assert(fs_mult > 0);
   // fs_shift = log2(fs_mult), rounded down.
   // Note that |fs_shift| is not "exact" for 48 kHz.
   // TODO(hlundin): Investigate this further.
   const int fs_shift = 30 - WebRtcSpl_NormW32(static_cast<int32_t>(fs_mult));
 
   // Check if last RecOut call resulted in an Expand. If so, we have to take
   // care of some cross-fading and unmuting.
   if (last_mode == kModeExpand) {
     // Generate interpolation data using Expand.
     // First, set Expand parameters to appropriate values.
     expand_->SetParametersForNormalAfterExpand();
 
     // Call Expand.
     AudioMultiVector expanded(output->Channels());
     expand_->Process(&expanded);
     expand_->Reset();
 
     for (size_t channel_ix = 0; channel_ix < output->Channels(); ++channel_ix) {
       // Adjust muting factor (main muting factor times expand muting factor).
       external_mute_factor_array[channel_ix] = static_cast<int16_t>(
           (external_mute_factor_array[channel_ix] *
           expand_->MuteFactor(channel_ix)) >> 14);
 
       int16_t* signal = &(*output)[channel_ix][0];
       size_t length_per_channel = length / output->Channels();
       // Find largest absolute value in new data.
-      int16_t decoded_max = WebRtcSpl_MaxAbsValueW16(
-        signal,  static_cast<int>(length_per_channel));
+      int16_t decoded_max =
+          WebRtcSpl_MaxAbsValueW16(signal, length_per_channel);
       // Adjust muting factor if needed (to BGN level).
-      int energy_length = std::min(static_cast<int>(fs_mult * 64),
-                                   static_cast<int>(length_per_channel));
+      size_t energy_length = std::min(fs_mult * 64, length_per_channel);
       int scaling = 6 + fs_shift
           - WebRtcSpl_NormW32(decoded_max * decoded_max);
       scaling = std::max(scaling, 0);  // |scaling| should always be >= 0.
       int32_t energy = WebRtcSpl_DotProductWithScale(signal, signal,
                                                      energy_length, scaling);
       int32_t scaled_energy_length =
           static_cast<int32_t>(energy_length >> scaling);
       if (scaled_energy_length > 0) {
         energy = energy / scaled_energy_length;
       } else {
@@ skipping 46 matching lines @@
         assert(channel_ix < output->Channels());
         assert(i < output->Size());
         (*output)[channel_ix][i] =
             static_cast<int16_t>((fraction * (*output)[channel_ix][i] +
                 (32 - fraction) * expanded[channel_ix][i] + 8) >> 5);
         fraction += increment;
       }
     }
   } else if (last_mode == kModeRfc3389Cng) {
     assert(output->Channels() == 1);  // Not adapted for multi-channel yet.
-    static const int kCngLength = 32;
+    static const size_t kCngLength = 32;
     int16_t cng_output[kCngLength];
     // Reset mute factor and start up fresh.
     external_mute_factor_array[0] = 16384;
     AudioDecoder* cng_decoder = decoder_database_->GetActiveCngDecoder();
 
     if (cng_decoder) {
       // Generate long enough for 32kHz.
       if (WebRtcCng_Generate(cng_decoder->CngDecoderInstance(), cng_output,
                              kCngLength, 0) < 0) {
         // Error returned; set return vector to all zeros.
@@ skipping 37 matching lines @@
         external_mute_factor_array[channel_ix] = static_cast<int16_t>(std::min(
             16384, external_mute_factor_array[channel_ix] + increment));
       }
     }
   }
 
   return static_cast<int>(length);
 }
 
 }  // namespace webrtc