DEPRECATED_NackModule::OnReceivedPacket

说明

OnReceivedPacket有两个函数
int OnReceivedPacket(uint16t seq_num, bool is_keyframe);
int OnReceivedPacket(uint16_t seq_num, bool is_keyframe, bool is_recovered);
前者调用了后者，第三个参数为false。
image.png
第一次进来需要初始化，然后第二个包进来就不需要初始化了。然后开始判断当前是否是上次处理前面的包，是则需要判断是否还在nack列表中，还在则需要删除。
image.png
如果是个新包，走下面的逻辑。
image.png
每个keyframe只有该keyframe第一个包，才会插入到keyframe_list中，其他位置的不插入。然后更新keyframe_list，只保存一万个值，将多出来的清理掉。接着往下走处理recoverd_list找回的包列表处理。
image.png
不是第一个包，不是一个重复的包，不是在newest_seq_num之前的包，也不是一个恢复的包，这时会跑到下面的逻辑。
image.png
AddPacketsToNack，将(newest_seq_num+1，seqnum)范围的包插入到NackList nack_list。
GetNackBatch拿到真正的丢包。

AddPacketsToNack

image.png
image.png

OnReceivedPacket源码

  1. int DEPRECATED_NackModule::OnReceivedPacket(uint16_t seq_num,
  2.                                             bool is_keyframe,
  3.                                             bool is_recovered) {
  4.   MutexLock lock(&mutex_);
  5.   // TODO(philipel): When the packet includes information whether it is
  6.   //                 retransmitted or not, use that value instead. For
  7.   //                 now set it to true, which will cause the reordering
  8.   //                 statistics to never be updated.
  9.   bool is_retransmitted = true;
  11.   if (!initialized_) {
  12.     newest_seq_num_ = seq_num;
  13.     if (is_keyframe)
  14.       keyframe_list_.insert(seq_num);
  15.     initialized_ = true;
  16.     return 0;
  17.   }
  19.   // Since the |newest_seq_num_| is a packet we have actually received we know
  20.   // that packet has never been Nacked.
  21.   if (seq_num == newest_seq_num_)
  22.     return 0;
  24.   if (AheadOf(newest_seq_num_, seq_num)) {
  25.     // An out of order packet has been received.
  26.     auto nack_list_it = nack_list_.find(seq_num);
  27.     int nacks_sent_for_packet = 0;
  28.     if (nack_list_it != nack_list_.end()) {
  29.       nacks_sent_for_packet = nack_list_it->second.retries;
  30.       nack_list_.erase(nack_list_it);
  31.     }
  32.     if (!is_retransmitted)
  33.       UpdateReorderingStatistics(seq_num);
  34.     return nacks_sent_for_packet;
  35.   }
  37.   // Keep track of new keyframes.
  38.   if (is_keyframe)
  39.     keyframe_list_.insert(seq_num);
  41.   // And remove old ones so we don't accumulate keyframes.
  42.   auto it = keyframe_list_.lower_bound(seq_num - kMaxPacketAge);
  43.   if (it != keyframe_list_.begin())
  44.     keyframe_list_.erase(keyframe_list_.begin(), it);
  46.   if (is_recovered) {
  47.     recovered_list_.insert(seq_num);
  49.     // Remove old ones so we don't accumulate recovered packets.
  50.     auto it = recovered_list_.lower_bound(seq_num - kMaxPacketAge);
  51.     if (it != recovered_list_.begin())
  52.       recovered_list_.erase(recovered_list_.begin(), it);
  54.     // Do not send nack for packets recovered by FEC or RTX.
  55.     return 0;
  56.   }
  58.   AddPacketsToNack(newest_seq_num_ + 1, seq_num);
  59.   newest_seq_num_ = seq_num;
  61.   // Are there any nacks that are waiting for this seq_num.
  62.   std::vector<uint16_t> nack_batch = GetNackBatch(kSeqNumOnly);
  63.   if (!nack_batch.empty()) {
  64.     // This batch of NACKs is triggered externally; the initiator can
  65.     // batch them with other feedback messages.
  66.     nack_sender_->SendNack(nack_batch, /*buffering_allowed=*/true);
  67.   }
  69.   return 0;
  70. }