Remove implicit-int-conversion warnings.

webrtc/video_engine/vie_channel.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 253 matching lines @@
       }
     }
 
     StreamDataCounters rtp;
     StreamDataCounters rtx;
     GetReceiveStreamDataCounters(&rtp, &rtx);
     StreamDataCounters rtp_rtx = rtp;
     rtp_rtx.Add(rtx);
     elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs(now) / 1000;
     if (elapsed_sec > metrics::kMinRunTimeInSeconds) {
-      RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.BitrateReceivedInKbps",
-          rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 1000);
-      RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.MediaBitrateReceivedInKbps",
-          rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000);
-      RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PaddingBitrateReceivedInKbps",
-          rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec / 1000);
+      RTC_HISTOGRAM_COUNTS_10000(
+          "WebRTC.Video.BitrateReceivedInKbps",
+          static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
+                           1000));
+      RTC_HISTOGRAM_COUNTS_10000(
+          "WebRTC.Video.MediaBitrateReceivedInKbps",
+          static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000));
+      RTC_HISTOGRAM_COUNTS_10000(
+          "WebRTC.Video.PaddingBitrateReceivedInKbps",
+          static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec /
+                           1000));
       RTC_HISTOGRAM_COUNTS_10000(
           "WebRTC.Video.RetransmittedBitrateReceivedInKbps",
-              rtp_rtx.retransmitted.TotalBytes() * 8 / elapsed_sec / 1000);
+          static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 /
+                           elapsed_sec / 1000));
       uint32_t ssrc = 0;
       if (vie_receiver_.GetRtxSsrc(&ssrc)) {
-        RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtxBitrateReceivedInKbps",
-            rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 1000);
+        RTC_HISTOGRAM_COUNTS_10000(
+            "WebRTC.Video.RtxBitrateReceivedInKbps",
+            static_cast<int>(rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
+                             1000));
       }
       if (vie_receiver_.IsFecEnabled()) {
         RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FecBitrateReceivedInKbps",
-            rtp_rtx.fec.TotalBytes() * 8 / elapsed_sec / 1000);
+                                   static_cast<int>(rtp_rtx.fec.TotalBytes() *
+                                                    8 / elapsed_sec / 1000));
       }
     }
   }
 }
 
 void ViEChannel::UpdateHistogramsAtStopSend() {
   StreamDataCounters rtp;
   StreamDataCounters rtx;
   GetSendStreamDataCounters(&rtp, &rtx);
   StreamDataCounters rtp_rtx = rtp;
   rtp_rtx.Add(rtx);
 
   int64_t elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs(
       Clock::GetRealTimeClock()->TimeInMilliseconds()) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds) {
     return;
   }
-  RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.BitrateSentInKbps",
-      rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 1000);
-  RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.MediaBitrateSentInKbps",
-      rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000);
-  RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PaddingBitrateSentInKbps",
-      rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec / 1000);
-  RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RetransmittedBitrateSentInKbps",
-      rtp_rtx.retransmitted.TotalBytes() * 8 / elapsed_sec / 1000);
+  RTC_HISTOGRAM_COUNTS_100000(
+      "WebRTC.Video.BitrateSentInKbps",
+      static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
+                       1000));
+  RTC_HISTOGRAM_COUNTS_10000(
+      "WebRTC.Video.MediaBitrateSentInKbps",
+      static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000));
+  RTC_HISTOGRAM_COUNTS_10000(
+      "WebRTC.Video.PaddingBitrateSentInKbps",
+      static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec /
+                       1000));
+  RTC_HISTOGRAM_COUNTS_10000(
+      "WebRTC.Video.RetransmittedBitrateSentInKbps",
+      static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / elapsed_sec /
+                       1000));
   if (rtp_rtcp_->RtxSendStatus() != kRtxOff) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtxBitrateSentInKbps",
-        rtx.transmitted.TotalBytes() * 8 / elapsed_sec / 1000);
+                               static_cast<int>(rtx.transmitted.TotalBytes() *
+                                                8 / elapsed_sec / 1000));
   }
   bool fec_enabled = false;
   uint8_t pltype_red;
   uint8_t pltype_fec;
   rtp_rtcp_->GenericFECStatus(fec_enabled, pltype_red, pltype_fec);
   if (fec_enabled) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FecBitrateSentInKbps",
-        rtp_rtx.fec.TotalBytes() * 8 / elapsed_sec / 1000);
+    RTC_HISTOGRAM_COUNTS_10000(
+        "WebRTC.Video.FecBitrateSentInKbps",
+        static_cast<int>(rtp_rtx.fec.TotalBytes() * 8 / elapsed_sec / 1000));
   }
 }
 
 int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec,
                                  bool new_stream) {
   if (!sender_) {
     return 0;
   }
   if (video_codec.codecType == kVideoCodecRED ||
       video_codec.codecType == kVideoCodecULPFEC) {
@@ skipping 31 matching lines @@
   rtp_rtcp_->GenericFECStatus(fec_enabled, payload_type_red, payload_type_fec);
 
   std::vector<RtpRtcp*> registered_modules;
   std::vector<RtpRtcp*> deregistered_modules;
   {
     CriticalSectionScoped cs(rtp_rtcp_cs_.get());
 
     if (video_codec.numberOfSimulcastStreams > 0) {
       // Set correct bitrate to base layer.
       // Create our simulcast RTP modules.
-      int num_modules_to_add =
-          video_codec.numberOfSimulcastStreams - simulcast_rtp_rtcp_.size() - 1;
+      int num_modules_to_add = video_codec.numberOfSimulcastStreams -
+                               static_cast<int>(simulcast_rtp_rtcp_.size()) - 1;
       if (num_modules_to_add < 0) {
         num_modules_to_add = 0;
       }
 
       // Add back removed rtp modules. Order is important (allocate from front
       // of removed modules) to preserve RTP settings such as SSRCs for
       // simulcast streams.
       std::list<RtpRtcp*> new_rtp_modules;
       for (; removed_rtp_rtcp_.size() > 0 && num_modules_to_add > 0;
            --num_modules_to_add) {
@@ skipping 28 matching lines @@
         rtp_rtcp->SetRtxSendPayloadType(payload_type_value.first,
                                         payload_type_value.second);
         rtp_rtcp->SetRtxSendStatus(rtp_rtcp_->RtxSendStatus());
         simulcast_rtp_rtcp_.push_back(rtp_rtcp);
 
         // Silently ignore error.
         registered_modules.push_back(rtp_rtcp);
       }
 
       // Remove last in list if we have too many.
-      for (int j = simulcast_rtp_rtcp_.size();
-           j > (video_codec.numberOfSimulcastStreams - 1); j--) {
+      for (size_t j = simulcast_rtp_rtcp_.size();
+           j > static_cast<size_t>(video_codec.numberOfSimulcastStreams - 1);
+           j--) {
         RtpRtcp* rtp_rtcp = simulcast_rtp_rtcp_.back();
         deregistered_modules.push_back(rtp_rtcp);
         rtp_rtcp->SetSendingStatus(false);
         rtp_rtcp->SetSendingMediaStatus(false);
         rtp_rtcp->RegisterRtcpStatisticsCallback(NULL);
         rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(NULL);
         simulcast_rtp_rtcp_.pop_back();
         removed_rtp_rtcp_.push_front(rtp_rtcp);
       }
       uint8_t idx = 0;
@@ skipping 1264 matching lines @@
   CriticalSectionScoped cs(callback_cs_.get());
   vcm_receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   CriticalSectionScoped cs(callback_cs_.get());
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc