保护因子的作用

image.png
保护因子的作用：是决定对一组媒体包产生多少个FEC包。

NumFecPackets

image.png
protection_factor 保护因子。
向右移8位，也就是除以256的原因，是因为webrtc的对包计算，是以256为单位计算的，也就是在256个包中，有多少个包丢失了。

保护因子从哪里来？

image.png
这类发现保护因子是从函数CurrentParams()函数得来的。

CurrentParams

image.png
后面查看是pendingparams是从SetProtectionParameters函数得来的。

SetProtectionParameters

image.png

更新FEC码调用栈

image.png
PostUpdates 更新目标码率，会周期调用。

UpdateFecRate

image.png
UpdateFecRate(评估码率， 真实帧率，丢包率，丢包的掩码数组，rtt时间)

ProtectionFactor计算保护因子

image.png
_maxPayloadSize : rtp包的最大字节，1460个。
effRateFecTable 有效码率
codeRateDelta 非关键帧的保护因子。关键帧的保护因子的计算方式跟这个差不多。
kFecRateTable 看《12-29 -FEC基础知识和原理》

  1. bool VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters) {
  2.   // FEC PROTECTION SETTINGS: varies with packet loss and bitrate
  4.   // No protection if (filtered) packetLoss is 0
  5.   uint8_t packetLoss = rtc::saturated_cast<uint8_t>(255 * parameters->lossPr);
  6.   if (packetLoss == 0) {
  7.     _protectionFactorK = 0;
  8.     _protectionFactorD = 0;
  9.     return true;
  10.   }
  12.   // Parameters for FEC setting:
  13.   // first partition size, thresholds, table pars, spatial resoln fac.
  15.   // First partition protection: ~ 20%
  16.   uint8_t firstPartitionProt = rtc::saturated_cast<uint8_t>(255 * 0.20);
  18.   // Minimum protection level needed to generate one FEC packet for one
  19.   // source packet/frame (in RTP sender)
  20.   uint8_t minProtLevelFec = 85;
  22.   // Threshold on packetLoss and bitRrate/frameRate (=average #packets),
  23.   // above which we allocate protection to cover at least first partition.
  24.   uint8_t lossThr = 0;
  25.   uint8_t packetNumThr = 1;
  27.   // Parameters for range of rate index of table.
  28.   const uint8_t ratePar1 = 5;
  29.   const uint8_t ratePar2 = 49;
  31.   // Spatial resolution size, relative to a reference size.
  32.   float spatialSizeToRef = rtc::saturated_cast<float>(parameters->codecWidth *
  33.                                                       parameters->codecHeight) /
  34.                            (rtc::saturated_cast<float>(704 * 576));
  35.   // resolnFac: This parameter will generally increase/decrease the FEC rate
  36.   // (for fixed bitRate and packetLoss) based on system size.
  37.   // Use a smaller exponent (< 1) to control/soften system size effect.
  38.   const float resolnFac = 1.0 / powf(spatialSizeToRef, 0.3f);
  40.   const int bitRatePerFrame = BitsPerFrame(parameters);
  42.   // Average number of packets per frame (source and fec):
  43.   const uint8_t avgTotPackets = rtc::saturated_cast<uint8_t>(
  44.       1.5f + rtc::saturated_cast<float>(bitRatePerFrame) * 1000.0f /
  45.                  rtc::saturated_cast<float>(8.0 * _maxPayloadSize));
  47.   // FEC rate parameters: for P and I frame
  48.   uint8_t codeRateDelta = 0;
  49.   uint8_t codeRateKey = 0;
  51.   // Get index for table: the FEC protection depends on an effective rate.
  52.   // The range on the rate index corresponds to rates (bps)
  53.   // from ~200k to ~8000k, for 30fps
  54.   const uint16_t effRateFecTable =
  55.       rtc::saturated_cast<uint16_t>(resolnFac * bitRatePerFrame);
  56.   uint8_t rateIndexTable = rtc::saturated_cast<uint8_t>(
  57.       VCM_MAX(VCM_MIN((effRateFecTable - ratePar1) / ratePar1, ratePar2), 0));
  59.   // Restrict packet loss range to 50:
  60.   // current tables defined only up to 50%
  61.   if (packetLoss >= kPacketLossMax) {
  62.     packetLoss = kPacketLossMax - 1;
  63.   }
  64.   uint16_t indexTable = rateIndexTable * kPacketLossMax + packetLoss;
  66.   // Check on table index
  67.   RTC_DCHECK_LT(indexTable, kFecRateTableSize);
  69.   // Protection factor for P frame
  70.   codeRateDelta = kFecRateTable[indexTable];
  72.   if (packetLoss > lossThr && avgTotPackets > packetNumThr) {
  73.     // Set a minimum based on first partition size.
  74.     if (codeRateDelta < firstPartitionProt) {
  75.       codeRateDelta = firstPartitionProt;
  76.     }
  77.   }
  79.   // Check limit on amount of protection for P frame; 50% is max.
  80.   if (codeRateDelta >= kPacketLossMax) {
  81.     codeRateDelta = kPacketLossMax - 1;
  82.   }
  84.   // For Key frame:
  85.   // Effectively at a higher rate, so we scale/boost the rate
  86.   // The boost factor may depend on several factors: ratio of packet
  87.   // number of I to P frames, how much protection placed on P frames, etc.
  88.   const uint8_t packetFrameDelta =
  89.       rtc::saturated_cast<uint8_t>(0.5 + parameters->packetsPerFrame);
  90.   const uint8_t packetFrameKey =
  91.       rtc::saturated_cast<uint8_t>(0.5 + parameters->packetsPerFrameKey);
  92.   const uint8_t boostKey = BoostCodeRateKey(packetFrameDelta, packetFrameKey);
  94.   rateIndexTable = rtc::saturated_cast<uint8_t>(VCM_MAX(
  95.       VCM_MIN(1 + (boostKey * effRateFecTable - ratePar1) / ratePar1, ratePar2),
  96.       0));
  97.   uint16_t indexTableKey = rateIndexTable * kPacketLossMax + packetLoss;
  99.   indexTableKey = VCM_MIN(indexTableKey, kFecRateTableSize);
  101.   // Check on table index
  102.   assert(indexTableKey < kFecRateTableSize);
  104.   // Protection factor for I frame
  105.   codeRateKey = kFecRateTable[indexTableKey];
  107.   // Boosting for Key frame.
  108.   int boostKeyProt = _scaleProtKey * codeRateDelta;
  109.   if (boostKeyProt >= kPacketLossMax) {
  110.     boostKeyProt = kPacketLossMax - 1;
  111.   }
  113.   // Make sure I frame protection is at least larger than P frame protection,
  114.   // and at least as high as filtered packet loss.
  115.   codeRateKey = rtc::saturated_cast<uint8_t>(
  116.       VCM_MAX(packetLoss, VCM_MAX(boostKeyProt, codeRateKey)));
  118.   // Check limit on amount of protection for I frame: 50% is max.
  119.   if (codeRateKey >= kPacketLossMax) {
  120.     codeRateKey = kPacketLossMax - 1;
  121.   }
  123.   _protectionFactorK = codeRateKey;
  124.   _protectionFactorD = codeRateDelta;
  126.   // Generally there is a rate mis-match between the FEC cost estimated
  127.   // in mediaOpt and the actual FEC cost sent out in RTP module.
  128.   // This is more significant at low rates (small # of source packets), where
  129.   // the granularity of the FEC decreases. In this case, non-zero protection
  130.   // in mediaOpt may generate 0 FEC packets in RTP sender (since actual #FEC
  131.   // is based on rounding off protectionFactor on actual source packet number).
  132.   // The correction factor (_corrFecCost) attempts to corrects this, at least
  133.   // for cases of low rates (small #packets) and low protection levels.
  135.   float numPacketsFl =
  136.       1.0f + (rtc::saturated_cast<float>(bitRatePerFrame) * 1000.0 /
  137.                   rtc::saturated_cast<float>(8.0 * _maxPayloadSize) +
  138.               0.5);
  140.   const float estNumFecGen =
  141.       0.5f +
  142.       rtc::saturated_cast<float>(_protectionFactorD * numPacketsFl / 255.0f);
  144.   // We reduce cost factor (which will reduce overhead for FEC and
  145.   // hybrid method) and not the protectionFactor.
  146.   _corrFecCost = 1.0f;
  147.   if (estNumFecGen < 1.1f && _protectionFactorD < minProtLevelFec) {
  148.     _corrFecCost = 0.5f;
  149.   }
  150.   if (estNumFecGen < 0.9f && _protectionFactorD < minProtLevelFec) {
  151.     _corrFecCost = 0.0f;
  152.   }
  154.   // DONE WITH FEC PROTECTION SETTINGS
  155.   return true;
  156. }