Update a ton of audio code to use size_t more correctly and in general reduce

webrtc/modules/audio_coding/main/acm2/acm_receiver.cc

 /*
  *  Copyright (c) 2013 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 326 matching lines @@
     LOG(LERROR) << "AcmReceiver::InsertPacket "
                 << static_cast<int>(header->payloadType)
                 << " Failed to insert packet";
     return -1;
   }
   return 0;
 }
 
 int AcmReceiver::GetAudio(int desired_freq_hz, AudioFrame* audio_frame) {
   enum NetEqOutputType type;
-  int samples_per_channel;
+  size_t samples_per_channel;
   int num_channels;
   bool return_silence = false;
 
   {
     // Accessing members, take the lock.
     CriticalSectionScoped lock(crit_sect_.get());
 
     if (av_sync_) {
       assert(initial_delay_manager_.get());
       assert(late_packets_sync_stream_.get());
@@ skipping 29 matching lines @@
   int decoded_sequence_num = 0;
   uint32_t decoded_timestamp = 0;
   bool update_nack = nack_enabled_ &&  // Update NACK only if it is enabled.
       neteq_->DecodedRtpInfo(&decoded_sequence_num, &decoded_timestamp);
   if (update_nack) {
     assert(nack_.get());
     nack_->UpdateLastDecodedPacket(decoded_sequence_num, decoded_timestamp);
   }
 
   // NetEq always returns 10 ms of audio.
-  current_sample_rate_hz_ = samples_per_channel * 100;
+  current_sample_rate_hz_ = static_cast<int>(samples_per_channel * 100);
 
   // Update if resampling is required.
   bool need_resampling = (desired_freq_hz != -1) &&
       (current_sample_rate_hz_ != desired_freq_hz);
 
   if (need_resampling && !resampled_last_output_frame_) {
     // Prime the resampler with the last frame.
     int16_t temp_output[AudioFrame::kMaxDataSizeSamples];
-    samples_per_channel =
+    int samples_per_channel_int =
         resampler_.Resample10Msec(last_audio_buffer_.get(),
                                   current_sample_rate_hz_,
                                   desired_freq_hz,
                                   num_channels,
                                   AudioFrame::kMaxDataSizeSamples,
                                   temp_output);
-    if (samples_per_channel < 0) {
+    if (samples_per_channel_int < 0) {
       LOG(LERROR) << "AcmReceiver::GetAudio - "
                      "Resampling last_audio_buffer_ failed.";
       return -1;
     }
+    samples_per_channel = static_cast<size_t>(samples_per_channel_int);
   }
 
   // The audio in |audio_buffer_| is tansferred to |audio_frame_| below, either
   // through resampling, or through straight memcpy.
   // TODO(henrik.lundin) Glitches in the output may appear if the output rate
   // from NetEq changes. See WebRTC issue 3923.
   if (need_resampling) {
-    samples_per_channel =
+    int samples_per_channel_int =
         resampler_.Resample10Msec(audio_buffer_.get(),
                                   current_sample_rate_hz_,
                                   desired_freq_hz,
                                   num_channels,
                                   AudioFrame::kMaxDataSizeSamples,
                                   audio_frame->data_);
-    if (samples_per_channel < 0) {
+    if (samples_per_channel_int < 0) {
       LOG(LERROR) << "AcmReceiver::GetAudio - Resampling audio_buffer_ failed.";
       return -1;
     }
+    samples_per_channel = static_cast<size_t>(samples_per_channel_int);
     resampled_last_output_frame_ = true;
   } else {
     resampled_last_output_frame_ = false;
     // We might end up here ONLY if codec is changed.
     memcpy(audio_frame->data_,
            audio_buffer_.get(),
            samples_per_channel * num_channels * sizeof(int16_t));
   }
 
   // Swap buffers, so that the current audio is stored in |last_audio_buffer_|
   // for next time.
   audio_buffer_.swap(last_audio_buffer_);
 
   audio_frame->num_channels_ = num_channels;
   audio_frame->samples_per_channel_ = samples_per_channel;
-  audio_frame->sample_rate_hz_ = samples_per_channel * 100;
+  audio_frame->sample_rate_hz_ = static_cast<int>(samples_per_channel * 100);
 
   // Should set |vad_activity| before calling SetAudioFrameActivityAndType().
   audio_frame->vad_activity_ = previous_audio_activity_;
   SetAudioFrameActivityAndType(vad_enabled_, type, audio_frame);
   previous_audio_activity_ = audio_frame->vad_activity_;
   call_stats_.DecodedByNetEq(audio_frame->speech_type_);
 
   // Computes the RTP timestamp of the first sample in |audio_frame| from
   // |GetPlayoutTimestamp|, which is the timestamp of the last sample of
   // |audio_frame|.
@@ skipping 318 matching lines @@
     frame->num_channels_ = 1;
   }
 
   // Set the audio frame's sampling frequency.
   if (desired_sample_rate_hz > 0) {
     frame->sample_rate_hz_ = desired_sample_rate_hz;
   } else {
     frame->sample_rate_hz_ = current_sample_rate_hz_;
   }
 
-  frame->samples_per_channel_ = frame->sample_rate_hz_ / 100;  // Always 10 ms.
+  frame->samples_per_channel_ =
+      static_cast<size_t>(frame->sample_rate_hz_ / 100);  // Always 10 ms.
   frame->speech_type_ = AudioFrame::kCNG;
   frame->vad_activity_ = AudioFrame::kVadPassive;
-  int samples = frame->samples_per_channel_ * frame->num_channels_;
+  size_t samples = frame->samples_per_channel_ * frame->num_channels_;
   memset(frame->data_, 0, samples * sizeof(int16_t));
   return true;
 }
 
 const AcmReceiver::Decoder* AcmReceiver::RtpHeaderToDecoder(
     const RTPHeader& rtp_header,
     const uint8_t* payload) const {
   auto it = decoders_.find(rtp_header.payloadType);
   if (ACMCodecDB::kRED >= 0 &&  // This ensures that RED is defined in WebRTC.
       it != decoders_.end() && ACMCodecDB::kRED == it->second.acm_codec_id) {
@@ skipping 35 matching lines @@
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
   CriticalSectionScoped lock(crit_sect_.get());
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc