Rename fec_tables_xor.h -> fec_rate_table.h

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/fec_rate_table.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;
 
 namespace media_optimization {
 
 VCMProtectionMethod::VCMProtectionMethod()
     : _effectivePacketLoss(0),
@@ skipping 268 matching lines @@
       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);
+  RTC_DCHECK_LT(indexTable, kFecRateTableSize);
 
   // Protection factor for P frame
-  codeRateDelta = kCodeRateXORTable[indexTable];
+  codeRateDelta = kFecRateTable[indexTable];
 
   if (packetLoss > lossThr && avgTotPackets > packetNumThr) {
     // Set a minimum based on first partition size.
     if (codeRateDelta < firstPartitionProt) {
       codeRateDelta = firstPartitionProt;
     }
   }
 
   // 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 =
       static_cast<uint8_t>(0.5 + parameters->packetsPerFrame);
   const uint8_t packetFrameKey =
       static_cast<uint8_t>(0.5 + parameters->packetsPerFrameKey);
   const uint8_t boostKey = BoostCodeRateKey(packetFrameDelta, packetFrameKey);
 
   rateIndexTable = static_cast<uint8_t>(VCM_MAX(
       VCM_MIN(1 + (boostKey * effRateFecTable - ratePar1) / ratePar1, ratePar2),
       0));
   uint16_t indexTableKey = rateIndexTable * kPacketLossMax + packetLoss;
 
-  indexTableKey = VCM_MIN(indexTableKey, kSizeCodeRateXORTable);
+  indexTableKey = VCM_MIN(indexTableKey, kFecRateTableSize);
 
   // Check on table index
-  assert(indexTableKey < kSizeCodeRateXORTable);
+  assert(indexTableKey < kFecRateTableSize);
 
   // Protection factor for I frame
-  codeRateKey = kCodeRateXORTable[indexTableKey];
+  codeRateKey = kFecRateTable[indexTableKey];
 
   // Boosting for Key frame.
   int boostKeyProt = _scaleProtKey * codeRateDelta;
   if (boostKeyProt >= kPacketLossMax) {
     boostKeyProt = kPacketLossMax - 1;
   }
 
   // Make sure I frame protection is at least larger than P frame protection,
   // and at least as high as filtered packet loss.
   codeRateKey = static_cast<uint8_t>(
@@ skipping 290 matching lines @@
   _shortMaxLossPr255 = 0;
   Release();
 }
 
 void VCMLossProtectionLogic::Release() {
   _selectedMethod.reset();
 }
 
 }  // namespace media_optimization
 }  // namespace webrtc