Match existing type usage better.

webrtc/modules/audio_coding/neteq/statistics_calculator.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 65 matching lines @@
 
 void StatisticsCalculator::PacketsDiscarded(int num_packets) {
   discarded_packets_ += num_packets;
 }
 
 void StatisticsCalculator::LostSamples(int num_samples) {
   lost_timestamps_ += num_samples;
 }
 
 void StatisticsCalculator::IncreaseCounter(int num_samples, int fs_hz) {
-  timestamps_since_last_report_ += num_samples;
+  timestamps_since_last_report_ += static_cast<uint32_t>(num_samples);
   if (timestamps_since_last_report_ >
       static_cast<uint32_t>(fs_hz * kMaxReportPeriod)) {
     lost_timestamps_ = 0;
     timestamps_since_last_report_ = 0;
     discarded_packets_ = 0;
   }
 }
 
 void StatisticsCalculator::SecondaryDecodedSamples(int num_samples) {
   secondary_decoded_samples_ += num_samples;
@@ skipping 17 matching lines @@
     int samples_per_packet,
     const DelayManager& delay_manager,
     const DecisionLogic& decision_logic,
     NetEqNetworkStatistics *stats) {
   if (fs_hz <= 0 || !stats) {
     assert(false);
     return;
   }
 
   stats->added_zero_samples = added_zero_samples_;
-  stats->current_buffer_size_ms = num_samples_in_buffers * 1000 / fs_hz;
+  stats->current_buffer_size_ms =
+      static_cast<uint16_t>(num_samples_in_buffers * 1000 / fs_hz);
   const int ms_per_packet = decision_logic.packet_length_samples() /
       (fs_hz / 1000);
   stats->preferred_buffer_size_ms = (delay_manager.TargetLevel() >> 8) *
       ms_per_packet;
   stats->jitter_peaks_found = delay_manager.PeakFound();
   stats->clockdrift_ppm = delay_manager.AverageIAT();
 
   stats->packet_loss_rate =
       CalculateQ14Ratio(lost_timestamps_, timestamps_since_last_report_);
 
@@ skipping 25 matching lines @@
 }
 
 void StatisticsCalculator::WaitingTimes(std::vector<int>* waiting_times) {
   if (!waiting_times) {
     return;
   }
   waiting_times->assign(waiting_times_, waiting_times_ + len_waiting_times_);
   ResetWaitingTimeStatistics();
 }
 
-int StatisticsCalculator::CalculateQ14Ratio(uint32_t numerator,
-                                            uint32_t denominator) {
+uint16_t StatisticsCalculator::CalculateQ14Ratio(uint32_t numerator,
+                                                 uint32_t denominator) {
   if (numerator == 0) {
     return 0;
   } else if (numerator < denominator) {
     // Ratio must be smaller than 1 in Q14.
     assert((numerator << 14) / denominator < (1 << 14));
-    return (numerator << 14) / denominator;
+    return static_cast<uint16_t>((numerator << 14) / denominator);
   } else {
     // Will not produce a ratio larger than 1, since this is probably an error.
     return 1 << 14;
   }
 }
 
 }  // namespace webrtc