Match existing type usage better.

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.
  */
 
@@ skipping 770 matching lines @@
       DoAlternativePlc(false);
       break;
     }
     case kAlternativePlcIncreaseTimestamp: {
       // TODO(hlundin): Write test for this.
       DoAlternativePlc(true);
       break;
     }
     case kAudioRepetitionIncreaseTimestamp: {
       // TODO(hlundin): Write test for this.
-      sync_buffer_->IncreaseEndTimestamp(output_size_samples_);
+      sync_buffer_->IncreaseEndTimestamp(
+          static_cast<uint32_t>(output_size_samples_));
       // Skipping break on purpose. Execution should move on into the
       // next case.
       FALLTHROUGH();
     }
     case kAudioRepetition: {
       // TODO(hlundin): Write test for this.
       // Copy last |output_size_samples_| from |sync_buffer_| to
       // |algorithm_buffer|.
       algorithm_buffer_->PushBackFromIndex(
           *sync_buffer_, sync_buffer_->Size() - output_size_samples_);
@@ skipping 72 matching lines @@
     // If last operation was not expand, calculate the |playout_timestamp_| from
     // the |sync_buffer_|. However, do not update the |playout_timestamp_| if it
     // would be moved "backwards".
     uint32_t temp_timestamp = sync_buffer_->end_timestamp() -
         static_cast<uint32_t>(sync_buffer_->FutureLength());
     if (static_cast<int32_t>(temp_timestamp - playout_timestamp_) > 0) {
       playout_timestamp_ = temp_timestamp;
     }
   } else {
     // Use dead reckoning to estimate the |playout_timestamp_|.
-    playout_timestamp_ += output_size_samples_;
+    playout_timestamp_ += static_cast<uint32_t>(output_size_samples_);
   }
 
   if (decode_return_value) return decode_return_value;
   return return_value;
 }
 
 int NetEqImpl::GetDecision(Operations* operation,
                            PacketList* packet_list,
                            DtmfEvent* dtmf_event,
                            bool* play_dtmf) {
@@ skipping 38 matching lines @@
       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_));
   }
 
   // Check if it is time to play a DTMF event.
-  if (dtmf_buffer_->GetEvent(end_timestamp +
-                             decision_logic_->generated_noise_samples(),
-                             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,
@@ skipping 67 matching lines @@
     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 = decision_logic_->generated_noise_samples();
+        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) {
@@ skipping 173 matching lines @@
   if ((*operation == kMerge) && decoder && decoder->HasDecodePlc()) {
     decoder->DecodePlc(1, &decoded_buffer_[*decoded_length]);
   }
 
   int return_value = DecodeLoop(packet_list, operation, decoder,
                                 decoded_length, speech_type);
 
   if (*decoded_length < 0) {
     // Error returned from the decoder.
     *decoded_length = 0;
-    sync_buffer_->IncreaseEndTimestamp(decoder_frame_length_);
+    sync_buffer_->IncreaseEndTimestamp(
+        static_cast<uint32_t>(decoder_frame_length_));
     int error_code = 0;
     if (decoder)
       error_code = decoder->ErrorCode();
     if (error_code != 0) {
       // Got some error code from the decoder.
       decoder_error_code_ = error_code;
       return_value = kDecoderErrorCode;
     } else {
       // Decoder does not implement error codes. Return generic error.
       return_value = kOtherDecoderError;
@@ skipping 474 matching lines @@
   //    // Not adapted for multi-channel yet.
   //    assert(algorithm_buffer_->Channels() == 1);
   //    if (algorithm_buffer_->Channels() != 1) {
   //      LOG(LS_WARNING) << "DTMF not supported for more than one channel";
   //      return kStereoNotSupported;
   //    }
   //    // Shuffle the remaining data to the beginning of algorithm buffer.
   //    algorithm_buffer_->PopFront(sync_buffer_->FutureLength());
   //  }
 
-  sync_buffer_->IncreaseEndTimestamp(output_size_samples_);
+  sync_buffer_->IncreaseEndTimestamp(
+      static_cast<uint32_t>(output_size_samples_));
   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;
   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) {
       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(length);
+    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.
 
   if (sync_buffer_->dtmf_index() > sync_buffer_->next_index()) {
@@ skipping 222 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