webrtc 소스 코드 읽기를 위한 NACK

NACK(Negative Acknowledgement) 메커니즘은 WebRTC에서 패킷 손실을 처리하기 위한 중요한 메커니즘입니다. 패킷이 손실된 경우 손실된 패킷을 다시 보내도록 발신자에게 알리는 데 사용됩니다. 수신자는 패킷 손실을 감지하면 송신자에게 NACK 메시지를 보내 손실된 패킷을 재전송하도록 요청합니다. 이 메커니즘은 특히 신뢰할 수 없는 네트워크 환경에서 통신 품질과 안정성을 향상시키는 데 도움이 될 수 있습니다.
이 기사에서는 webrtc의 소스 코드에서 nack의 구현 및 버전을 분석합니다 m98.

1. NackRequester::OnReceivedPacket

int NackRequester::OnReceivedPacket(uint16_t seq_num,
                                    bool is_keyframe,
                                    bool is_recovered) {
    
    
  RTC_DCHECK_RUN_ON(worker_thread_);
  // TODO(philipel): When the packet includes information whether it is
  //                 retransmitted or not, use that value instead. For
  //                 now set it to true, which will cause the reordering
  //                 statistics to never be updated.
  bool is_retransmitted = true;

  if (!initialized_) {
    
      //如果没有初始化，就初始化，设置newest_seq_num_
    newest_seq_num_ = seq_num;
    if (is_keyframe) //如果是关键帧，则插入关键帧队列
      keyframe_list_.insert(seq_num);
    initialized_ = true;
    return 0;
  }

  // Since the `newest_seq_num_` is a packet we have actually received we know
  // that packet has never been Nacked.
  if (seq_num == newest_seq_num_) //当前帧等于最新帧，说明无需更新nack模块
    return 0;

  if (AheadOf(newest_seq_num_, seq_num)) {
    
       //当前帧比最新帧序列号要老，说明是乱序帧，或者是重传帧
    // An out of order packet has been received.
    auto nack_list_it = nack_list_.find(seq_num);
    int nacks_sent_for_packet = 0;
    if (nack_list_it != nack_list_.end()) {
    
       //在丢包队列里找到了，说明当前帧是重传帧，更新信息，并在丢包队列里清除掉当前帧
      nacks_sent_for_packet = nack_list_it->second.retries;
      nack_list_.erase(nack_list_it);
    }
    if (!is_retransmitted)  //永远不会触发
      UpdateReorderingStatistics(seq_num);
    return nacks_sent_for_packet;
  }

  // Keep track of new keyframes.
  if (is_keyframe) //如果是关键帧，则插入关键帧队列
    keyframe_list_.insert(seq_num);

  // And remove old ones so we don't accumulate keyframes.
  //清除掉太老的关键帧，最多10000包
  auto it = keyframe_list_.lower_bound(seq_num - kMaxPacketAge);
  if (it != keyframe_list_.begin())
    keyframe_list_.erase(keyframe_list_.begin(), it);

  if (is_recovered) {
    
      //recovered 说明是fec包恢复的，则更新recovered_list_
    recovered_list_.insert(seq_num);

    // Remove old ones so we don't accumulate recovered packets.
    auto it = recovered_list_.lower_bound(seq_num - kMaxPacketAge);
    if (it != recovered_list_.begin())
      recovered_list_.erase(recovered_list_.begin(), it);

    // Do not send nack for packets recovered by FEC or RTX.
    return 0;
  }

  //将newest_seq_num_ + 1 至 seq_num的所有包添加至Nack队列
  AddPacketsToNack(newest_seq_num_ + 1, seq_num);
  newest_seq_num_ = seq_num;

  // Are there any nacks that are waiting for this seq_num.
  //获取nack包组
  std::vector<uint16_t> nack_batch = GetNackBatch(kSeqNumOnly);
  if (!nack_batch.empty()) {
    
    
    // This batch of NACKs is triggered externally; the initiator can
    // batch them with other feedback messages.
    //打包并发送nack信息
    nack_sender_->SendNack(nack_batch, /*buffering_allowed=*/true);
  }

  return 0;
}

NackRequester::OnReceivedPacketwebrtc는 rtp 데이터를 수신한 후 nack 관련 정보를 업데이트하고 처리하도록 호출합니다 . 에서 NackRequester::OnReceivedPacket먼저 순서가 잘못된 패킷인지 재전송된 패킷인지 판단하고 패킷 손실 대기열을 업데이트하고, 그렇지 않으면 새로운 손실 NackRequester::AddPacketsToNack패킷을 패킷 손실 대기열로 업데이트하고 마지막으로 NackRequester::GetNackBatch손실 패킷 그룹을 얻은 후 NackSender를 통해 전송합니다. .

二、NackRequester::AddPacketsToNack

void NackRequester::AddPacketsToNack(uint16_t seq_num_start,
                                     uint16_t seq_num_end) {
    
    
  // Called on worker_thread_.
  // Remove old packets.
  //清除太旧的Nack包
  auto it = nack_list_.lower_bound(seq_num_end - kMaxPacketAge);
  nack_list_.erase(nack_list_.begin(), it);

  // If the nack list is too large, remove packets from the nack list until
  // the latest first packet of a keyframe. If the list is still too large,
  // clear it and request a keyframe.
  uint16_t num_new_nacks = ForwardDiff(seq_num_start, seq_num_end);
  //如果要插入的nack包数目+当前数目超过最大包数目，就按关键帧队列，清除关键帧之前的nac包
  if (nack_list_.size() + num_new_nacks > kMaxNackPackets) {
    
    
    while (RemovePacketsUntilKeyFrame() &&
           nack_list_.size() + num_new_nacks > kMaxNackPackets) {
    
    
    }

    //清除以后还是空间还是不够，就清空nack队列，请求关键帧
    if (nack_list_.size() + num_new_nacks > kMaxNackPackets) {
    
    
      nack_list_.clear();
      RTC_LOG(LS_WARNING) << "NACK list full, clearing NACK"
                             " list and requesting keyframe.";
      keyframe_request_sender_->RequestKeyFrame();
      return;
    }
  }

  //依次把待插入的nack包插入nack队列
  for (uint16_t seq_num = seq_num_start; seq_num != seq_num_end; ++seq_num) {
    
    
    // Do not send nack for packets that are already recovered by FEC or RTX
    if (recovered_list_.find(seq_num) != recovered_list_.end())
      continue;
    NackInfo nack_info(seq_num, seq_num + WaitNumberOfPackets(0.5),
                       clock_->TimeInMilliseconds());
    RTC_DCHECK(nack_list_.find(seq_num) == nack_list_.end());
    nack_list_[seq_num] = nack_info;
  }
}

nack 패킷을 삽입하는 로직은 비교적 간단하며, 최대 패킷 수를 판단하는 것으로, 초과할 경우 키 프레임 번호에 따라 nack 큐를 비우고, 청소 후에도 여전히 한도를 초과하면 nack queue는 nack 대기열이 지워지고 발신자로부터 키 프레임이 요청됩니다.

3. NackRequester::GetNackBatch

std::vector<uint16_t> NackRequester::GetNackBatch(NackFilterOptions options) {
    
    
  // Called on worker_thread_.
  //两种模式
  bool consider_seq_num = options != kTimeOnly;
  bool consider_timestamp = options != kSeqNumOnly;
  Timestamp now = clock_->CurrentTime();
  std::vector<uint16_t> nack_batch;
  auto it = nack_list_.begin();
  while (it != nack_list_.end()) {
    
    
    TimeDelta resend_delay = TimeDelta::Millis(rtt_ms_);
    //根据配置选项，计算重传补偿延迟值，不配置的话就是一个rtt
    if (backoff_settings_) {
    
    
      resend_delay =
          std::max(resend_delay, backoff_settings_->min_retry_interval);
      if (it->second.retries > 1) {
    
    
        TimeDelta exponential_backoff =
            std::min(TimeDelta::Millis(rtt_ms_), backoff_settings_->max_rtt) *
            std::pow(backoff_settings_->base, it->second.retries - 1);
        resend_delay = std::max(resend_delay, exponential_backoff);
      }
    }

    bool delay_timed_out =
        now.ms() - it->second.created_at_time >= send_nack_delay_ms_;  //可以通过配置nack发送延迟来设置,0-20ms，默认是0；
    bool nack_on_rtt_passed =
        now.ms() - it->second.sent_at_time >= resend_delay.ms(); //是否超过了nack重传延迟
    bool nack_on_seq_num_passed =
        it->second.sent_at_time == -1 &&
        AheadOrAt(newest_seq_num_, it->second.send_at_seq_num);  //是否是第一次发送nack，且序列号小于最新包
    if (delay_timed_out && ((consider_seq_num && nack_on_seq_num_passed) ||
                            (consider_timestamp && nack_on_rtt_passed))) {
    
     //满足条件，将nack序列放入nack_batch
      nack_batch.emplace_back(it->second.seq_num);
      ++it->second.retries;
      it->second.sent_at_time = now.ms();
      if (it->second.retries >= kMaxNackRetries) {
    
    
        RTC_LOG(LS_WARNING) << "Sequence number " << it->second.seq_num
                            << " removed from NACK list due to max retries.";
        it = nack_list_.erase(it);
      } else {
    
    
        ++it;
      }
      continue;
    }
    ++it;
  }
  return nack_batch;
}

GetNackBatch에는 일련 번호 모드와 타임스탬프 모드를 기반으로 하는 두 가지 모드가 있습니다. 시리얼 넘버 모드에 따르면 rtp를 수신하여 처음으로 패킷 손실을 확인한 후 시리얼 넘버 모드에 따라 패킷 손실 요청을 보내고 타임스탬프 모드에 따라 일정 시간에 주기적으로 패킷 손실 요청을 보냅니다. 간격.
중요한 매개변수:

• resend_delay: 패킷 손실 재전송 간격, 기본값은 1rtt입니다. backoff_settings_를 구성하여 수정할 수 있습니다. 예를 들어 최소 재전송 간격을 설정하여 rtt가 작을 때 빈번한 재전송 요청을 방지하도록 min_retry_interval을 구성할 수 있습니다.
• send_nack_delay_ms_: 첫 번째 패킷 손실 재전송 지연. 정상적인 순서를 벗어난 패킷이 수신되면 기본 메커니즘은 기본적으로 NACK을 직접 반환합니다.NACK 지연 전송 시간 간격을 제어하여 고정 지연 네트워크에서 불필요한 재전송 요청을 피할 수 있습니다. 예를 들어, kDefaultSendNackDelayMs=20ms인 경우 일부 데이터 패킷이 네트워크 고유의 지연으로 인해 10ms 지연되고 현재 NACK 지연 전송 메커니즘이 없는 경우 이러한 패킷은 손실된 것으로 간주되며 이러한 패킷이 요청됩니다. 재전송 예정 . 그러나 20ms의 NACK 지연이 있는 경우 이러한 패킷은 손실된 것으로 간주되지 않으므로 불필요한 재전송 요청 및 리소스 낭비를 피할 수 있습니다.

NACK 전송의 논리 분석이 완료되었으며 특정 패키징 전송 및 수신 처리는 이 기사에서 분석되지 않습니다.