Replace c-style cast and constrain value in VCMFecMethod::ProtectionFactor.

webrtc/modules/video_coding/media_opt_util.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/video_coding/media_opt_util.h"
 
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 
 #include <algorithm>
+#include <limits>
 
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/modules/video_coding/fec_tables_xor.h"
 #include "webrtc/modules/video_coding/nack_fec_tables.h"
 
 namespace webrtc {
 // Max value of loss rates in off-line model
 static const int kPacketLossMax = 129;
@@ skipping 209 matching lines @@
 
 // Update FEC with protectionFactorK
 void VCMFecMethod::UpdateProtectionFactorK(uint8_t protectionFactorK) {
   _protectionFactorK = protectionFactorK;
 }
 
 bool VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters) {
   // FEC PROTECTION SETTINGS: varies with packet loss and bitrate
 
   // No protection if (filtered) packetLoss is 0
-  uint8_t packetLoss = (uint8_t)(255 * parameters->lossPr);
+  uint8_t packetLoss = static_cast<uint8_t>(255 * parameters->lossPr);
   if (packetLoss == 0) {
     _protectionFactorK = 0;
     _protectionFactorD = 0;
     return true;
   }
 
   // Parameters for FEC setting:
   // first partition size, thresholds, table pars, spatial resoln fac.
 
   // First partition protection: ~ 20%
-  uint8_t firstPartitionProt = (uint8_t)(255 * 0.20);
+  uint8_t firstPartitionProt = static_cast<uint8_t>(255 * 0.20);
 
   // Minimum protection level needed to generate one FEC packet for one
   // source packet/frame (in RTP sender)
   uint8_t minProtLevelFec = 85;
 
   // Threshold on packetLoss and bitRrate/frameRate (=average #packets),
   // above which we allocate protection to cover at least first partition.
   uint8_t lossThr = 0;
   uint8_t packetNumThr = 1;
 
   // Parameters for range of rate index of table.
   const uint8_t ratePar1 = 5;
   const uint8_t ratePar2 = 49;
 
   // Spatial resolution size, relative to a reference size.
   float spatialSizeToRef =
       static_cast<float>(parameters->codecWidth * parameters->codecHeight) /
       (static_cast<float>(704 * 576));
   // resolnFac: This parameter will generally increase/decrease the FEC rate
   // (for fixed bitRate and packetLoss) based on system size.
   // Use a smaller exponent (< 1) to control/soften system size effect.
   const float resolnFac = 1.0 / powf(spatialSizeToRef, 0.3f);
 
   const int bitRatePerFrame = BitsPerFrame(parameters);
 
   // Average number of packets per frame (source and fec):
-  const uint8_t avgTotPackets =
-      1 + (uint8_t)(static_cast<float>(bitRatePerFrame) * 1000.0 /
-                        static_cast<float>(8.0 * _maxPayloadSize) +
-                    0.5);
+  const uint8_t avgTotPackets = static_cast<uint8_t>(
+      std::min(static_cast<float>(std::numeric_limits<uint8_t>::max()),
+               1.5f +
+                   static_cast<float>(bitRatePerFrame) * 1000.0f /
+                       static_cast<float>(8.0 * _maxPayloadSize)));
 
   // FEC rate parameters: for P and I frame
   uint8_t codeRateDelta = 0;
   uint8_t codeRateKey = 0;
 
   // Get index for table: the FEC protection depends on an effective rate.
   // The range on the rate index corresponds to rates (bps)
   // from ~200k to ~8000k, for 30fps
   const uint16_t effRateFecTable =
       static_cast<uint16_t>(resolnFac * bitRatePerFrame);
-  uint8_t rateIndexTable = (uint8_t)VCM_MAX(
-      VCM_MIN((effRateFecTable - ratePar1) / ratePar1, ratePar2), 0);
+  uint8_t rateIndexTable = static_cast<uint8_t>(
+      VCM_MAX(VCM_MIN((effRateFecTable - ratePar1) / ratePar1, ratePar2), 0));
 
   // Restrict packet loss range to 50:
   // current tables defined only up to 50%
   if (packetLoss >= kPacketLossMax) {
     packetLoss = kPacketLossMax - 1;
   }
   uint16_t indexTable = rateIndexTable * kPacketLossMax + packetLoss;
 
   // Check on table index
   assert(indexTable < kSizeCodeRateXORTable);
@@ skipping 10 matching lines @@
 
   // Check limit on amount of protection for P frame; 50% is max.
   if (codeRateDelta >= kPacketLossMax) {
     codeRateDelta = kPacketLossMax - 1;
   }
 
   // For Key frame:
   // Effectively at a higher rate, so we scale/boost the rate
   // The boost factor may depend on several factors: ratio of packet
   // number of I to P frames, how much protection placed on P frames, etc.
-  const uint8_t packetFrameDelta = (uint8_t)(0.5 + parameters->packetsPerFrame);
+  const uint8_t packetFrameDelta =
+      static_cast<uint8_t>(0.5 + parameters->packetsPerFrame);
   const uint8_t packetFrameKey =
-      (uint8_t)(0.5 + parameters->packetsPerFrameKey);
+      static_cast<uint8_t>(0.5 + parameters->packetsPerFrameKey);
   const uint8_t boostKey = BoostCodeRateKey(packetFrameDelta, packetFrameKey);
 
-  rateIndexTable = (uint8_t)VCM_MAX(
+  rateIndexTable = static_cast<uint8_t>(VCM_MAX(
       VCM_MIN(1 + (boostKey * effRateFecTable - ratePar1) / ratePar1, ratePar2),
-      0);
+      0));
   uint16_t indexTableKey = rateIndexTable * kPacketLossMax + packetLoss;
 
   indexTableKey = VCM_MIN(indexTableKey, kSizeCodeRateXORTable);
 
   // Check on table index
   assert(indexTableKey < kSizeCodeRateXORTable);
 
   // Protection factor for I frame
   codeRateKey = kCodeRateXORTable[indexTableKey];
 
@@ skipping 299 matching lines @@
   _shortMaxLossPr255 = 0;
   Release();
 }
 
 void VCMLossProtectionLogic::Release() {
   _selectedMethod.reset();
 }
 
 }  // namespace media_optimization
 }  // namespace webrtc