Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/neteq_impl.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/neteq_impl.h"
 
 #include <assert.h>
 #include <memory.h>  // memset
 
 #include <algorithm>
 
 #include "webrtc/base/logging.h"
+#include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/neteq/accelerate.h"
 #include "webrtc/modules/audio_coding/neteq/background_noise.h"
 #include "webrtc/modules/audio_coding/neteq/buffer_level_filter.h"
 #include "webrtc/modules/audio_coding/neteq/comfort_noise.h"
 #include "webrtc/modules/audio_coding/neteq/decision_logic.h"
 #include "webrtc/modules/audio_coding/neteq/decoder_database.h"
 #include "webrtc/modules/audio_coding/neteq/defines.h"
 #include "webrtc/modules/audio_coding/neteq/delay_manager.h"
@@ skipping 68 matching lines @@
       decoded_packet_timestamp_(0) {
   LOG(LS_INFO) << "NetEq config: " << config.ToString();
   int fs = config.sample_rate_hz;
   if (fs != 8000 && fs != 16000 && fs != 32000 && fs != 48000) {
     LOG(LS_ERROR) << "Sample rate " << fs << " Hz not supported. " <<
         "Changing to 8000 Hz.";
     fs = 8000;
   }
   fs_hz_ = fs;
   fs_mult_ = fs / 8000;
-  output_size_samples_ = kOutputSizeMs * 8 * fs_mult_;
+  output_size_samples_ = static_cast<size_t>(kOutputSizeMs * 8 * fs_mult_);
   decoder_frame_length_ = 3 * output_size_samples_;
   WebRtcSpl_Init();
   if (create_components) {
     SetSampleRateAndChannels(fs, 1);  // Default is 1 channel.
   }
 }
 
 NetEqImpl::~NetEqImpl() = default;
 
 int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header,
@@ skipping 29 matching lines @@
       rtp_header, kSyncPayload, sizeof(kSyncPayload), receive_timestamp, true);
 
   if (error != 0) {
     error_code_ = error;
     return kFail;
   }
   return kOK;
 }
 
 int NetEqImpl::GetAudio(size_t max_length, int16_t* output_audio,
-                        int* samples_per_channel, int* num_channels,
+                        size_t* samples_per_channel, int* num_channels,
                         NetEqOutputType* type) {
   CriticalSectionScoped lock(crit_sect_.get());
   LOG(LS_VERBOSE) << "GetAudio";
   int error = GetAudioInternal(max_length, output_audio, samples_per_channel,
                                num_channels);
   LOG(LS_VERBOSE) << "Produced " << *samples_per_channel <<
       " samples/channel for " << *num_channels << " channel(s)";
   if (error != 0) {
     error_code_ = error;
     return kFail;
@@ skipping 130 matching lines @@
 // Deprecated.
 // TODO(henrik.lundin) Delete.
 NetEqPlayoutMode NetEqImpl::PlayoutMode() const {
   CriticalSectionScoped lock(crit_sect_.get());
   return playout_mode_;
 }
 
 int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) {
   CriticalSectionScoped lock(crit_sect_.get());
   assert(decoder_database_.get());
-  const int total_samples_in_buffers =
+  const size_t total_samples_in_buffers =
       packet_buffer_->NumSamplesInBuffer(decoder_database_.get(),
                                          decoder_frame_length_) +
-      static_cast<int>(sync_buffer_->FutureLength());
+      sync_buffer_->FutureLength();
   assert(delay_manager_.get());
   assert(decision_logic_.get());
   stats_.GetNetworkStatistics(fs_hz_, total_samples_in_buffers,
                               decoder_frame_length_, *delay_manager_.get(),
                               *decision_logic_.get(), stats);
   return 0;
 }
 
 void NetEqImpl::WaitingTimes(std::vector<int>* waiting_times) {
   CriticalSectionScoped lock(crit_sect_.get());
@@ skipping 274 matching lines @@
     assert(decoder);  // Should always get a valid object, since we have
                       // already checked that the payload types are known.
     decoder->IncomingPacket(packet_list.front()->payload,
                             packet_list.front()->payload_length,
                             packet_list.front()->header.sequenceNumber,
                             packet_list.front()->header.timestamp,
                             receive_timestamp);
   }
 
   // Insert packets in buffer.
-  int temp_bufsize = packet_buffer_->NumPacketsInBuffer();
+  size_t temp_bufsize = packet_buffer_->NumPacketsInBuffer();
   ret = packet_buffer_->InsertPacketList(
       &packet_list,
       *decoder_database_,
       &current_rtp_payload_type_,
       &current_cng_rtp_payload_type_);
   if (ret == PacketBuffer::kFlushed) {
     // Reset DSP timestamp etc. if packet buffer flushed.
     new_codec_ = true;
     update_sample_rate_and_channels = true;
   } else if (ret != PacketBuffer::kOK) {
@@ skipping 41 matching lines @@
   assert(dec_info);  // Already checked that the payload type is known.
   delay_manager_->LastDecoderType(dec_info->codec_type);
   if (delay_manager_->last_pack_cng_or_dtmf() == 0) {
     // Calculate the total speech length carried in each packet.
     temp_bufsize = packet_buffer_->NumPacketsInBuffer() - temp_bufsize;
     temp_bufsize *= decoder_frame_length_;
 
     if ((temp_bufsize > 0) &&
         (temp_bufsize != decision_logic_->packet_length_samples())) {
       decision_logic_->set_packet_length_samples(temp_bufsize);
-      delay_manager_->SetPacketAudioLength((1000 * temp_bufsize) / fs_hz_);
+      delay_manager_->SetPacketAudioLength(
+          static_cast<int>((1000 * temp_bufsize) / fs_hz_));
     }
 
     // Update statistics.
     if ((int32_t) (main_header.timestamp - timestamp_) >= 0 &&
         !new_codec_) {
       // Only update statistics if incoming packet is not older than last played
       // out packet, and if new codec flag is not set.
       delay_manager_->Update(main_header.sequenceNumber, main_header.timestamp,
                              fs_hz_);
     }
   } else if (delay_manager_->last_pack_cng_or_dtmf() == -1) {
     // This is first "normal" packet after CNG or DTMF.
     // Reset packet time counter and measure time until next packet,
     // but don't update statistics.
     delay_manager_->set_last_pack_cng_or_dtmf(0);
     delay_manager_->ResetPacketIatCount();
   }
   return 0;
 }
 
 int NetEqImpl::GetAudioInternal(size_t max_length,
                                 int16_t* output,
-                                int* samples_per_channel,
+                                size_t* samples_per_channel,
                                 int* num_channels) {
   PacketList packet_list;
   DtmfEvent dtmf_event;
   Operations operation;
   bool play_dtmf;
   int return_value = GetDecision(&operation, &packet_list, &dtmf_event,
                                  &play_dtmf);
   if (return_value != 0) {
     assert(false);
     last_mode_ = kModeError;
     return return_value;
   }
   LOG(LS_VERBOSE) << "GetDecision returned operation=" << operation <<
       " and " << packet_list.size() << " packet(s)";
 
   AudioDecoder::SpeechType speech_type;
   int length = 0;
   int decode_return_value = Decode(&packet_list, &operation,
                                    &length, &speech_type);
 
   assert(vad_.get());
   bool sid_frame_available =
       (operation == kRfc3389Cng && !packet_list.empty());
-  vad_->Update(decoded_buffer_.get(), length, speech_type,
+  vad_->Update(decoded_buffer_.get(), static_cast<size_t>(length), speech_type,
                sid_frame_available, fs_hz_);
 
   algorithm_buffer_->Clear();
   switch (operation) {
     case kNormal: {
       DoNormal(decoded_buffer_.get(), length, speech_type, play_dtmf);
       break;
     }
     case kMerge: {
       DoMerge(decoded_buffer_.get(), length, speech_type, play_dtmf);
@@ skipping 78 matching lines @@
   // Copy from |algorithm_buffer| to |sync_buffer_|.
   sync_buffer_->PushBack(*algorithm_buffer_);
 
   // Extract data from |sync_buffer_| to |output|.
   size_t num_output_samples_per_channel = output_size_samples_;
   size_t num_output_samples = output_size_samples_ * sync_buffer_->Channels();
   if (num_output_samples > max_length) {
     LOG(LS_WARNING) << "Output array is too short. " << max_length << " < " <<
         output_size_samples_ << " * " << sync_buffer_->Channels();
     num_output_samples = max_length;
-    num_output_samples_per_channel = static_cast<int>(
-        max_length / sync_buffer_->Channels());
+    num_output_samples_per_channel = max_length / sync_buffer_->Channels();
   }
-  const int samples_from_sync =
-      static_cast<int>(sync_buffer_->GetNextAudioInterleaved(
-          num_output_samples_per_channel, output));
+  const size_t samples_from_sync =
+      sync_buffer_->GetNextAudioInterleaved(num_output_samples_per_channel,
+                                            output);
   *num_channels = static_cast<int>(sync_buffer_->Channels());
   LOG(LS_VERBOSE) << "Sync buffer (" << *num_channels << " channel(s)):" <<
       " insert " << algorithm_buffer_->Size() << " samples, extract " <<
       samples_from_sync << " samples";
   if (samples_from_sync != output_size_samples_) {
     LOG(LS_ERROR) << "samples_from_sync (" << samples_from_sync
                   << ") != output_size_samples_ (" << output_size_samples_
                   << ")";
     // TODO(minyue): treatment of under-run, filling zeros
     memset(output, 0, num_output_samples * sizeof(int16_t));
@@ skipping 85 matching lines @@
   }
 
   assert(expand_.get());
   const int samples_left = static_cast<int>(sync_buffer_->FutureLength() -
       expand_->overlap_length());
   if (last_mode_ == kModeAccelerateSuccess ||
       last_mode_ == kModeAccelerateLowEnergy ||
       last_mode_ == kModePreemptiveExpandSuccess ||
       last_mode_ == kModePreemptiveExpandLowEnergy) {
     // Subtract (samples_left + output_size_samples_) from sampleMemory.
-    decision_logic_->AddSampleMemory(-(samples_left + output_size_samples_));
+    decision_logic_->AddSampleMemory(
+        -(samples_left + rtc::checked_cast<int>(output_size_samples_)));
   }
 
   // Check if it is time to play a DTMF event.
   if (dtmf_buffer_->GetEvent(
       static_cast<uint32_t>(
           end_timestamp + decision_logic_->generated_noise_samples()),
       dtmf_event)) {
     *play_dtmf = true;
   }
 
   // Get instruction.
   assert(sync_buffer_.get());
   assert(expand_.get());
   *operation = decision_logic_->GetDecision(*sync_buffer_,
                                             *expand_,
                                             decoder_frame_length_,
                                             header,
                                             last_mode_,
                                             *play_dtmf,
                                             &reset_decoder_);
 
   // Check if we already have enough samples in the |sync_buffer_|. If so,
   // change decision to normal, unless the decision was merge, accelerate, or
   // preemptive expand.
-  if (samples_left >= output_size_samples_ && *operation != kMerge &&
-      *operation != kAccelerate && *operation != kFastAccelerate &&
+  if (samples_left >= rtc::checked_cast<int>(output_size_samples_) &&
+      *operation != kMerge &&
+      *operation != kAccelerate &&
+      *operation != kFastAccelerate &&
       *operation != kPreemptiveExpand) {
     *operation = kNormal;
     return 0;
   }
 
   decision_logic_->ExpandDecision(*operation);
 
   // Check conditions for reset.
   if (new_codec_ || *operation == kUndefined) {
     // The only valid reason to get kUndefined is that new_codec_ is set.
@@ skipping 27 matching lines @@
     // new value.
     sync_buffer_->IncreaseEndTimestamp(timestamp_ - end_timestamp);
     end_timestamp = timestamp_;
     new_codec_ = false;
     decision_logic_->SoftReset();
     buffer_level_filter_->Reset();
     delay_manager_->Reset();
     stats_.ResetMcu();
   }
 
-  int required_samples = output_size_samples_;
-  const int samples_10_ms = 80 * fs_mult_;
-  const int samples_20_ms = 2 * samples_10_ms;
-  const int samples_30_ms = 3 * samples_10_ms;
+  size_t required_samples = output_size_samples_;
+  const size_t samples_10_ms = static_cast<size_t>(80 * fs_mult_);
+  const size_t samples_20_ms = 2 * samples_10_ms;
+  const size_t samples_30_ms = 3 * samples_10_ms;
 
   switch (*operation) {
     case kExpand: {
       timestamp_ = end_timestamp;
       return 0;
     }
     case kRfc3389CngNoPacket:
     case kCodecInternalCng: {
       return 0;
     }
     case kDtmf: {
       // TODO(hlundin): Write test for this.
       // Update timestamp.
       timestamp_ = end_timestamp;
       if (decision_logic_->generated_noise_samples() > 0 &&
           last_mode_ != kModeDtmf) {
         // Make a jump in timestamp due to the recently played comfort noise.
         uint32_t timestamp_jump =
             static_cast<uint32_t>(decision_logic_->generated_noise_samples());
         sync_buffer_->IncreaseEndTimestamp(timestamp_jump);
         timestamp_ += timestamp_jump;
       }
       decision_logic_->set_generated_noise_samples(0);
       return 0;
     }
     case kAccelerate:
     case kFastAccelerate: {
       // In order to do an accelerate we need at least 30 ms of audio data.
-      if (samples_left >= samples_30_ms) {
+      if (samples_left >= static_cast<int>(samples_30_ms)) {
         // Already have enough data, so we do not need to extract any more.
         decision_logic_->set_sample_memory(samples_left);
         decision_logic_->set_prev_time_scale(true);
         return 0;
-      } else if (samples_left >= samples_10_ms &&
+      } else if (samples_left >= static_cast<int>(samples_10_ms) &&
           decoder_frame_length_ >= samples_30_ms) {
         // Avoid decoding more data as it might overflow the playout buffer.
         *operation = kNormal;
         return 0;
-      } else if (samples_left < samples_20_ms &&
+      } else if (samples_left < static_cast<int>(samples_20_ms) &&
           decoder_frame_length_ < samples_30_ms) {
         // Build up decoded data by decoding at least 20 ms of audio data. Do
         // not perform accelerate yet, but wait until we only need to do one
         // decoding.
         required_samples = 2 * output_size_samples_;
         *operation = kNormal;
       }
       // If none of the above is true, we have one of two possible situations:
       // (1) 20 ms <= samples_left < 30 ms and decoder_frame_length_ < 30 ms; or
       // (2) samples_left < 10 ms and decoder_frame_length_ >= 30 ms.
       // In either case, we move on with the accelerate decision, and decode one
       // frame now.
       break;
     }
     case kPreemptiveExpand: {
       // In order to do a preemptive expand we need at least 30 ms of decoded
       // audio data.
-      if ((samples_left >= samples_30_ms) ||
-          (samples_left >= samples_10_ms &&
+      if ((samples_left >= static_cast<int>(samples_30_ms)) ||
+          (samples_left >= static_cast<int>(samples_10_ms) &&
               decoder_frame_length_ >= samples_30_ms)) {
         // Already have enough data, so we do not need to extract any more.
         // Or, avoid decoding more data as it might overflow the playout buffer.
         // Still try preemptive expand, though.
         decision_logic_->set_sample_memory(samples_left);
         decision_logic_->set_prev_time_scale(true);
         return 0;
       }
-      if (samples_left < samples_20_ms &&
+      if (samples_left < static_cast<int>(samples_20_ms) &&
           decoder_frame_length_ < samples_30_ms) {
         // Build up decoded data by decoding at least 20 ms of audio data.
         // Still try to perform preemptive expand.
         required_samples = 2 * output_size_samples_;
       }
       // Move on with the preemptive expand decision.
       break;
     }
     case kMerge: {
       required_samples =
@@ skipping 36 matching lines @@
   }
 
   if (*operation == kAccelerate || *operation == kFastAccelerate ||
       *operation == kPreemptiveExpand) {
     decision_logic_->set_sample_memory(samples_left + extracted_samples);
     decision_logic_->set_prev_time_scale(true);
   }
 
   if (*operation == kAccelerate || *operation == kFastAccelerate) {
     // Check that we have enough data (30ms) to do accelerate.
-    if (extracted_samples + samples_left < samples_30_ms) {
+    if (extracted_samples + samples_left < static_cast<int>(samples_30_ms)) {
       // TODO(hlundin): Write test for this.
       // Not enough, do normal operation instead.
       *operation = kNormal;
     }
   }
 
   timestamp_ = end_timestamp;
   return 0;
 }
 
@@ skipping 130 matching lines @@
       // Decode to silence with the same frame size as the last decode.
       LOG(LS_VERBOSE) << "Decoding sync-packet: " <<
           " ts=" << packet->header.timestamp <<
           ", sn=" << packet->header.sequenceNumber <<
           ", pt=" << static_cast<int>(packet->header.payloadType) <<
           ", ssrc=" << packet->header.ssrc <<
           ", len=" << packet->payload_length;
       memset(&decoded_buffer_[*decoded_length], 0,
              decoder_frame_length_ * decoder->Channels() *
                  sizeof(decoded_buffer_[0]));
-      decode_length = decoder_frame_length_;
+      decode_length = rtc::checked_cast<int>(decoder_frame_length_);
     } else if (!packet->primary) {
       // This is a redundant payload; call the special decoder method.
       LOG(LS_VERBOSE) << "Decoding packet (redundant):" <<
           " ts=" << packet->header.timestamp <<
           ", sn=" << packet->header.sequenceNumber <<
           ", pt=" << static_cast<int>(packet->header.payloadType) <<
           ", ssrc=" << packet->header.ssrc <<
           ", len=" << packet->payload_length;
       decode_length = decoder->DecodeRedundant(
           packet->payload, packet->payload_length, fs_hz_,
@@ skipping 12 matching lines @@
               &decoded_buffer_[*decoded_length], speech_type);
     }
 
     delete[] packet->payload;
     delete packet;
     packet = NULL;
     if (decode_length > 0) {
       *decoded_length += decode_length;
       // Update |decoder_frame_length_| with number of samples per channel.
       decoder_frame_length_ =
-          decode_length / static_cast<int>(decoder->Channels());
+          static_cast<size_t>(decode_length) / decoder->Channels();
       LOG(LS_VERBOSE) << "Decoded " << decode_length << " samples ("
                       << decoder->Channels() << " channel(s) -> "
                       << decoder_frame_length_ << " samples per channel)";
     } else if (decode_length < 0) {
       // Error.
       LOG(LS_WARNING) << "Decode " << decode_length << " " << payload_length;
       *decoded_length = -1;
       PacketBuffer::DeleteAllPackets(packet_list);
       break;
     }
@@ skipping 38 matching lines @@
 
   if (!play_dtmf) {
     dtmf_tone_generator_->Reset();
   }
 }
 
 void NetEqImpl::DoMerge(int16_t* decoded_buffer, size_t decoded_length,
                         AudioDecoder::SpeechType speech_type, bool play_dtmf) {
   assert(mute_factor_array_.get());
   assert(merge_.get());
-  int new_length = merge_->Process(decoded_buffer, decoded_length,
-                                   mute_factor_array_.get(),
-                                   algorithm_buffer_.get());
-  int expand_length_correction = new_length -
-      static_cast<int>(decoded_length / algorithm_buffer_->Channels());
+  size_t new_length = merge_->Process(decoded_buffer, decoded_length,
+                                      mute_factor_array_.get(),
+                                      algorithm_buffer_.get());
+  size_t expand_length_correction = new_length -
+      decoded_length / algorithm_buffer_->Channels();
 
   // Update in-call and post-call statistics.
   if (expand_->MuteFactor(0) == 0) {
     // Expand generates only noise.
     stats_.ExpandedNoiseSamples(expand_length_correction);
   } else {
     // Expansion generates more than only noise.
     stats_.ExpandedVoiceSamples(expand_length_correction);
   }
 
   last_mode_ = kModeMerge;
   // If last packet was decoded as an inband CNG, set mode to CNG instead.
   if (speech_type == AudioDecoder::kComfortNoise) {
     last_mode_ = kModeCodecInternalCng;
   }
   expand_->Reset();
   if (!play_dtmf) {
     dtmf_tone_generator_->Reset();
   }
 }
 
 int NetEqImpl::DoExpand(bool play_dtmf) {
   while ((sync_buffer_->FutureLength() - expand_->overlap_length()) <
-      static_cast<size_t>(output_size_samples_)) {
+      output_size_samples_) {
     algorithm_buffer_->Clear();
     int return_value = expand_->Process(algorithm_buffer_.get());
-    int length = static_cast<int>(algorithm_buffer_->Size());
+    size_t length = algorithm_buffer_->Size();
 
     // Update in-call and post-call statistics.
     if (expand_->MuteFactor(0) == 0) {
       // Expand operation generates only noise.
       stats_.ExpandedNoiseSamples(length);
     } else {
       // Expand operation generates more than only noise.
       stats_.ExpandedVoiceSamples(length);
     }
 
@@ skipping 10 matching lines @@
     dtmf_tone_generator_->Reset();
   }
   return 0;
 }
 
 int NetEqImpl::DoAccelerate(int16_t* decoded_buffer,
                             size_t decoded_length,
                             AudioDecoder::SpeechType speech_type,
                             bool play_dtmf,
                             bool fast_accelerate) {
-  const size_t required_samples = 240 * fs_mult_;  // Must have 30 ms.
+  const size_t required_samples =
+      static_cast<size_t>(240 * fs_mult_);  // Must have 30 ms.
   size_t borrowed_samples_per_channel = 0;
   size_t num_channels = algorithm_buffer_->Channels();
   size_t decoded_length_per_channel = decoded_length / num_channels;
   if (decoded_length_per_channel < required_samples) {
     // Must move data from the |sync_buffer_| in order to get 30 ms.
     borrowed_samples_per_channel = static_cast<int>(required_samples -
         decoded_length_per_channel);
     memmove(&decoded_buffer[borrowed_samples_per_channel * num_channels],
             decoded_buffer,
             sizeof(int16_t) * decoded_length);
     sync_buffer_->ReadInterleavedFromEnd(borrowed_samples_per_channel,
                                          decoded_buffer);
     decoded_length = required_samples * num_channels;
   }
 
-  int16_t samples_removed;
+  size_t samples_removed;
   Accelerate::ReturnCodes return_code =
       accelerate_->Process(decoded_buffer, decoded_length, fast_accelerate,
                            algorithm_buffer_.get(), &samples_removed);
   stats_.AcceleratedSamples(samples_removed);
   switch (return_code) {
     case Accelerate::kSuccess:
       last_mode_ = kModeAccelerateSuccess;
       break;
     case Accelerate::kSuccessLowEnergy:
       last_mode_ = kModeAccelerateLowEnergy;
@@ skipping 36 matching lines @@
     dtmf_tone_generator_->Reset();
   }
   expand_->Reset();
   return 0;
 }
 
 int NetEqImpl::DoPreemptiveExpand(int16_t* decoded_buffer,
                                   size_t decoded_length,
                                   AudioDecoder::SpeechType speech_type,
                                   bool play_dtmf) {
-  const size_t required_samples = 240 * fs_mult_;  // Must have 30 ms.
+  const size_t required_samples =
+      static_cast<size_t>(240 * fs_mult_);  // Must have 30 ms.
   size_t num_channels = algorithm_buffer_->Channels();
-  int borrowed_samples_per_channel = 0;
-  int old_borrowed_samples_per_channel = 0;
+  size_t borrowed_samples_per_channel = 0;
+  size_t old_borrowed_samples_per_channel = 0;
   size_t decoded_length_per_channel = decoded_length / num_channels;
   if (decoded_length_per_channel < required_samples) {
     // Must move data from the |sync_buffer_| in order to get 30 ms.
-    borrowed_samples_per_channel = static_cast<int>(required_samples -
-        decoded_length_per_channel);
+    borrowed_samples_per_channel =
+        required_samples - decoded_length_per_channel;
     // Calculate how many of these were already played out.
-    const int future_length = static_cast<int>(sync_buffer_->FutureLength());
     old_borrowed_samples_per_channel =
-        (borrowed_samples_per_channel > future_length) ?
-        (borrowed_samples_per_channel - future_length) : 0;
+        (borrowed_samples_per_channel > sync_buffer_->FutureLength()) ?
+        (borrowed_samples_per_channel - sync_buffer_->FutureLength()) : 0;
     memmove(&decoded_buffer[borrowed_samples_per_channel * num_channels],
             decoded_buffer,
             sizeof(int16_t) * decoded_length);
     sync_buffer_->ReadInterleavedFromEnd(borrowed_samples_per_channel,
                                          decoded_buffer);
     decoded_length = required_samples * num_channels;
   }
 
-  int16_t samples_added;
+  size_t samples_added;
   PreemptiveExpand::ReturnCodes return_code = preemptive_expand_->Process(
-      decoded_buffer, static_cast<int>(decoded_length),
+      decoded_buffer, decoded_length,
       old_borrowed_samples_per_channel,
       algorithm_buffer_.get(), &samples_added);
   stats_.PreemptiveExpandedSamples(samples_added);
   switch (return_code) {
     case PreemptiveExpand::kSuccess:
       last_mode_ = kModePreemptiveExpandSuccess;
       break;
     case PreemptiveExpand::kSuccessLowEnergy:
       last_mode_ = kModePreemptiveExpandLowEnergy;
       break;
@@ skipping 173 matching lines @@
   expand_->Reset();
   last_mode_ = kModeDtmf;
 
   // Set to false because the DTMF is already in the algorithm buffer.
   *play_dtmf = false;
   return 0;
 }
 
 void NetEqImpl::DoAlternativePlc(bool increase_timestamp) {
   AudioDecoder* decoder = decoder_database_->GetActiveDecoder();
-  int length;
+  size_t length;
   if (decoder && decoder->HasDecodePlc()) {
     // Use the decoder's packet-loss concealment.
     // TODO(hlundin): Will probably need a longer buffer for multi-channel.
     int16_t decoded_buffer[kMaxFrameSize];
     length = decoder->DecodePlc(1, decoded_buffer);
-    if (length > 0) {
+    if (length > 0)
       algorithm_buffer_->PushBackInterleaved(decoded_buffer, length);
-    } else {
-      length = 0;
-    }
   } else {
     // Do simple zero-stuffing.
     length = output_size_samples_;
     algorithm_buffer_->Zeros(length);
     // By not advancing the timestamp, NetEq inserts samples.
     stats_.AddZeros(length);
   }
   if (increase_timestamp) {
     sync_buffer_->IncreaseEndTimestamp(static_cast<uint32_t>(length));
   }
   expand_->Reset();
 }
 
 int NetEqImpl::DtmfOverdub(const DtmfEvent& dtmf_event, size_t num_channels,
                            int16_t* output) const {
   size_t out_index = 0;
-  int overdub_length = output_size_samples_;  // Default value.
+  size_t overdub_length = output_size_samples_;  // Default value.
 
   if (sync_buffer_->dtmf_index() > sync_buffer_->next_index()) {
     // Special operation for transition from "DTMF only" to "DTMF overdub".
     out_index = std::min(
         sync_buffer_->dtmf_index() - sync_buffer_->next_index(),
-        static_cast<size_t>(output_size_samples_));
-    overdub_length = output_size_samples_ - static_cast<int>(out_index);
+        output_size_samples_);
+    overdub_length = output_size_samples_ - out_index;
   }
 
   AudioMultiVector dtmf_output(num_channels);
   int dtmf_return_value = 0;
   if (!dtmf_tone_generator_->initialized()) {
     dtmf_return_value = dtmf_tone_generator_->Init(fs_hz_, dtmf_event.event_no,
                                                    dtmf_event.volume);
   }
   if (dtmf_return_value == 0) {
     dtmf_return_value = dtmf_tone_generator_->Generate(overdub_length,
                                                        &dtmf_output);
-    assert((size_t) overdub_length == dtmf_output.Size());
+    assert(overdub_length == dtmf_output.Size());
   }
   dtmf_output.ReadInterleaved(overdub_length, &output[out_index]);
   return dtmf_return_value < 0 ? dtmf_return_value : 0;
 }
 
-int NetEqImpl::ExtractPackets(int required_samples, PacketList* packet_list) {
+int NetEqImpl::ExtractPackets(size_t required_samples,
+                              PacketList* packet_list) {
   bool first_packet = true;
   uint8_t prev_payload_type = 0;
   uint32_t prev_timestamp = 0;
   uint16_t prev_sequence_number = 0;
   bool next_packet_available = false;
 
   const RTPHeader* header = packet_buffer_->NextRtpHeader();
   assert(header);
   if (!header) {
     LOG(LS_ERROR) << "Packet buffer unexpectedly empty.";
     return -1;
   }
   uint32_t first_timestamp = header->timestamp;
   int extracted_samples = 0;
 
   // Packet extraction loop.
   do {
     timestamp_ = header->timestamp;
-    int discard_count = 0;
+    size_t discard_count = 0;
     Packet* packet = packet_buffer_->GetNextPacket(&discard_count);
     // |header| may be invalid after the |packet_buffer_| operation.
     header = NULL;
     if (!packet) {
       LOG(LS_ERROR) << "Should always be able to extract a packet here";
       assert(false);  // Should always be able to extract a packet here.
       return -1;
     }
     stats_.PacketsDiscarded(discard_count);
     // Store waiting time in ms; packets->waiting_time is in "output blocks".
     stats_.StoreWaitingTime(packet->waiting_time * kOutputSizeMs);
     assert(packet->payload_length > 0);
     packet_list->push_back(packet);  // Store packet in list.
 
     if (first_packet) {
       first_packet = false;
       decoded_packet_sequence_number_ = prev_sequence_number =
           packet->header.sequenceNumber;
       decoded_packet_timestamp_ = prev_timestamp = packet->header.timestamp;
       prev_payload_type = packet->header.payloadType;
     }
 
     // Store number of extracted samples.
     int packet_duration = 0;
     AudioDecoder* decoder = decoder_database_->GetDecoder(
         packet->header.payloadType);
     if (decoder) {
       if (packet->sync_packet) {
-        packet_duration = decoder_frame_length_;
+        packet_duration = rtc::checked_cast<int>(decoder_frame_length_);
       } else {
         if (packet->primary) {
           packet_duration = decoder->PacketDuration(packet->payload,
                                                     packet->payload_length);
         } else {
           packet_duration = decoder->
               PacketDurationRedundant(packet->payload, packet->payload_length);
           stats_.SecondaryDecodedSamples(packet_duration);
         }
       }
     } else {
       LOG(LS_WARNING) << "Unknown payload type "
                       << static_cast<int>(packet->header.payloadType);
       assert(false);
     }
     if (packet_duration <= 0) {
       // Decoder did not return a packet duration. Assume that the packet
       // contains the same number of samples as the previous one.
-      packet_duration = decoder_frame_length_;
+      packet_duration = rtc::checked_cast<int>(decoder_frame_length_);
     }
     extracted_samples = packet->header.timestamp - first_timestamp +
         packet_duration;
 
     // Check what packet is available next.
     header = packet_buffer_->NextRtpHeader();
     next_packet_available = false;
     if (header && prev_payload_type == header->payloadType) {
       int16_t seq_no_diff = header->sequenceNumber - prev_sequence_number;
-      int32_t ts_diff = header->timestamp - prev_timestamp;
+      size_t ts_diff = header->timestamp - prev_timestamp;
       if (seq_no_diff == 1 ||
           (seq_no_diff == 0 && ts_diff == decoder_frame_length_)) {
         // The next sequence number is available, or the next part of a packet
         // that was split into pieces upon insertion.
         next_packet_available = true;
       }
       prev_sequence_number = header->sequenceNumber;
     }
-  } while (extracted_samples < required_samples && next_packet_available);
+  } while (extracted_samples < rtc::checked_cast<int>(required_samples) &&
+           next_packet_available);
 
   if (extracted_samples > 0) {
     // Delete old packets only when we are going to decode something. Otherwise,
     // we could end up in the situation where we never decode anything, since
     // all incoming packets are considered too old but the buffer will also
     // never be flooded and flushed.
     packet_buffer_->DiscardAllOldPackets(timestamp_);
   }
 
   return extracted_samples;
 }
 
 void NetEqImpl::UpdatePlcComponents(int fs_hz, size_t channels) {
   // Delete objects and create new ones.
   expand_.reset(expand_factory_->Create(background_noise_.get(),
                                         sync_buffer_.get(), &random_vector_,
                                         fs_hz, channels));
   merge_.reset(new Merge(fs_hz, channels, expand_.get(), sync_buffer_.get()));
 }
 
 void NetEqImpl::SetSampleRateAndChannels(int fs_hz, size_t channels) {
   LOG(LS_VERBOSE) << "SetSampleRateAndChannels " << fs_hz << " " << channels;
   // TODO(hlundin): Change to an enumerator and skip assert.
   assert(fs_hz == 8000 || fs_hz == 16000 || fs_hz ==  32000 || fs_hz == 48000);
   assert(channels > 0);
 
   fs_hz_ = fs_hz;
   fs_mult_ = fs_hz / 8000;
-  output_size_samples_ = kOutputSizeMs * 8 * fs_mult_;
+  output_size_samples_ = static_cast<size_t>(kOutputSizeMs * 8 * fs_mult_);
   decoder_frame_length_ = 3 * output_size_samples_;  // Initialize to 30ms.
 
   last_mode_ = kModeNormal;
 
   // Create a new array of mute factors and set all to 1.
   mute_factor_array_.reset(new int16_t[channels]);
   for (size_t i = 0; i < channels; ++i) {
     mute_factor_array_[i] = 16384;  // 1.0 in Q14.
   }
 
@@ skipping 24 matching lines @@
 
   // Move index so that we create a small set of future samples (all 0).
   sync_buffer_->set_next_index(sync_buffer_->next_index() -
       expand_->overlap_length());
 
   normal_.reset(new Normal(fs_hz, decoder_database_.get(), *background_noise_,
                            expand_.get()));
   accelerate_.reset(
       accelerate_factory_->Create(fs_hz, channels, *background_noise_));
   preemptive_expand_.reset(preemptive_expand_factory_->Create(
-      fs_hz, channels,
-      *background_noise_,
-      static_cast<int>(expand_->overlap_length())));
+      fs_hz, channels, *background_noise_, expand_->overlap_length()));
 
   // Delete ComfortNoise object and create a new one.
   comfort_noise_.reset(new ComfortNoise(fs_hz, decoder_database_.get(),
                                         sync_buffer_.get()));
 
   // Verify that |decoded_buffer_| is long enough.
   if (decoded_buffer_length_ < kMaxFrameSize * channels) {
     // Reallocate to larger size.
     decoded_buffer_length_ = kMaxFrameSize * channels;
     decoded_buffer_.reset(new int16_t[decoded_buffer_length_]);
@@ skipping 26 matching lines @@
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(fs_hz_, output_size_samples_,
                                               playout_mode_,
                                               decoder_database_.get(),
                                               *packet_buffer_.get(),
                                               delay_manager_.get(),
                                               buffer_level_filter_.get()));
 }
 }  // namespace webrtc