• WebRTC研究：丢包与抖动

    1、累计收包、重传包等信息，并计算抖动：

    1. void StreamStatisticianImpl::UpdateCounters(const RTPHeader& header,
    2.                                             size_t packet_length,
    3.                                             bool retransmitted) 
    4. {
    5.   rtc::CritScope cs(&stream_lock_);
    6.  
    7.   /*
    8.   判断包是否有序
    9.   判断标准：当前收包seq位于区间：[received_seq_max_ - max_reordering_threshold, received_seq_max_] 之外
    10.   max_reordering_threshold，默认为50
    11.   */
    12.   bool in_order = InOrderPacketInternal(header.sequenceNumber);
    13.   ssrc_ = header.ssrc;
    14.  
    15.   // 累计所收到的包数、字节数
    16.   incoming_bitrate_.Update(packet_length);
    17.  
    18.   // 累计所收到的包数、header/padding/payload字节数（packet_length是包总长度）
    19.   receive_counters_.transmitted.AddPacket(packet_length, header);
    20.  
    21.   // 累计所收到的无序重传包数、字节数
    22.   if (!in_order && retransmitted) 
    23.   {
    24.     receive_counters_.retransmitted.AddPacket(packet_length, header);
    25.   }
    26.  
    27.   // 记录所收到的第一个包的seq、当前时间
    28.   if (receive_counters_.transmitted.packets == 1) 
    29.   {
    30.     received_seq_first_ = header.sequenceNumber;
    31.     receive_counters_.first_packet_time_ms = clock_->TimeInMilliseconds();
    32.   }
    33.  
    34.   // 收到有序包
    35.   // Count only the new packets received. That is, if packets 1, 2, 3, 5, 4, 6
    36.   // are received, 4 will be ignored.
    37.   if (in_order) 
    38.   {
    39.     // Current time in samples.
    40.     NtpTime receive_time(*clock_);
    41.  
    42.     // Wrong if we use RetransmitOfOldPacket.
    43.  
    44. 	// 回绕
    45.     if (receive_counters_.transmitted.packets > 1 && received_seq_max_ > header.sequenceNumber) 
    46. 	{
    47.       // Wrap around detected.
    48.       received_seq_wraps_++;
    49.     }
    50.  
    51.     // 记录最新 seq
    52.     received_seq_max_ = header.sequenceNumber;
    53.  
    54.     // 计算最新抖动
    55.     if (header.timestamp != last_received_timestamp_ &&
    56.         (receive_counters_.transmitted.packets - receive_counters_.retransmitted.packets) > 1) 
    57. 	{
    58.       UpdateJitter(header, receive_time);
    59.     }
    60.  
    61. 	// 记录最近 所收到的最新包头携带的时间戳、收到最新包时的本地NTP时间与当前时间
    62.     last_received_timestamp_ = header.timestamp;
    63.     last_receive_time_ntp_ = receive_time;
    64.     last_receive_time_ms_ = clock_->TimeInMilliseconds();
    65.   }
    66.  
    67.   size_t packet_oh = header.headerLength + header.paddingLength;
    68.  
    69.   // Our measured overhead. Filter from RFC 5104 4.2.1.2:
    70.   // avg_OH (new) = 15/16*avg_OH (old) + 1/16*pckt_OH,
    71.   received_packet_overhead_ = (15 * received_packet_overhead_ + packet_oh) >> 4;
    72. }

    判断包是否有序：

    1. bool StreamStatisticianImpl::InOrderPacketInternal(uint16_t sequence_number) const 
    2. {
    3.   // First packet is always in order.
    4.   if (last_receive_time_ms_ == 0)
    5.     return true;
    6.  
    7.   if (IsNewerSequenceNumber(sequence_number, received_seq_max_)) 
    8.   {
    9.     return true;
    10.   } 
    11.   else 
    12.   {
    13.     // If we have a restart of the remote side this packet is still in order.
    14.     return !IsNewerSequenceNumber(sequence_number, received_seq_max_ - max_reordering_threshold_);
    15.   }
    16. }

    计算抖动：

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

    1. void StreamStatisticianImpl::UpdateJitter(const RTPHeader& header, NtpTime receive_time) 
    2. {
    3.   // 将NTP时间戳：receive_time（本地当前NTP时间）转变成RTP时间戳
    4.   uint32_t receive_time_rtp = NtpToRtp(receive_time, header.payload_type_frequency);
    5.   // 将NTP时间戳：last_receive_time_ntp_（最近收到最新包时的本地NTP时间）转变成RTP时间戳
    6.   uint32_t last_receive_time_rtp = NtpToRtp(last_receive_time_ntp_, header.payload_type_frequency);
    7.  
    8.   // 第一种计算抖动的方法：jitter_q4_
    9.   /*
    10.   计算（最近两次收到最新包时的本地NTP时间差）与（最近两次收到最新包头携带的时间戳）之差
    11.   即：计算抖动值，理想情况下，抖动值为0
    12.   */
    13.   int32_t time_diff_samples = (receive_time_rtp - last_receive_time_rtp) -
    14.       (header.timestamp - last_received_timestamp_);
    15.  
    16.   time_diff_samples = std::abs(time_diff_samples);
    17.  
    18.   // lib_jingle sometimes deliver crazy jumps in TS for the same stream.
    19.   // If this happens, don't update jitter value. Use 5 secs video frequency
    20.   // as the threshold.
    22.   // 更新 jitter_q4_
    23.   if (time_diff_samples < 450000) 
    24.   {
    25.     // Note we calculate in Q4 to avoid using float.
    26.     int32_t jitter_diff_q4 = (time_diff_samples << 4) - jitter_q4_;
    27.     jitter_q4_ += ((jitter_diff_q4 + 8) >> 4);
    28.   }
    30.   // 第二种计算抖动的方法：jitter_q4_transmission_time_offset_
    31.   // transmission_time_offset：一段时间间隔，代表属于同一帧的RTP的实际发送时间距离帧的capture time的偏移量
    32.   // 即计算（最近两次收到最新包时的本地NTP时间差）与（最近两次收到最新包实际发送到网络的时间戳）之差
    33.   int32_t time_diff_samples_ext = (receive_time_rtp - last_receive_time_rtp) -
    34.     ((header.timestamp + header.extension.transmissionTimeOffset) -
    35.      (last_received_timestamp_ + last_received_transmission_time_offset_));
    37.   time_diff_samples_ext = std::abs(time_diff_samples_ext);
    39.   // 计算 jitter_q4_transmission_time_offset_
    40.   if (time_diff_samples_ext < 450000) 
    41.   {
    42.     int32_t jitter_diffQ4TransmissionTimeOffset = (time_diff_samples_ext << 4) - jitter_q4_transmission_time_offset_;
    43.     jitter_q4_transmission_time_offset_ += ((jitter_diffQ4TransmissionTimeOffset + 8) >> 4);
    44.   }
    45. }

    二、丢包统计

    每发送一次RTP包，就会进行一次丢包统计（即丢包统计的周期：5000ms）。

    1、调用流程

    void ModuleRtpRtcpImpl::Process()

    int32_t RTCPSender::SendRTCP(…)

    int32_t RTCPSender::SendCompoundRTCP(…)

    void RTCPSender::PrepareReport(…)

    1. void RTCPSender::PrepareReport(const std::set<RTCPPacketType>& packetTypes,
    2.                                const FeedbackState& feedback_state) 
    3. {
    4.   ...
    5.   ...
    6.   ...
    7.    
    8.    if (receive_statistics_) 
    9.    {
    10.       StatisticianMap statisticians = receive_statistics_->GetActiveStatisticians();
    11.  
    12.       RTC_DCHECK(report_blocks_.empty());
    13.       for (auto& it : statisticians) 
    14. 	  {
    15.         AddReportBlock(feedback_state, it.first, it.second);
    16.       }
    17.   }
    18. }
    1. bool RTCPSender::AddReportBlock(const FeedbackState& feedback_state,
    2.                                 uint32_t ssrc,
    3.                                 StreamStatistician* statistician) 
    4. {
    5.   RtcpStatistics stats;
    6.   if (!statistician->GetStatistics(&stats, true))
    7.     return false;
    8.     
    9.   ...
    10.   ...
    11.   ...
    12. }
    1. bool StreamStatisticianImpl::GetStatistics(RtcpStatistics* statistics, bool reset) 
    2. {
    3.   {
    4.     rtc::CritScope cs(&stream_lock_);
    5. 	/*
    6. 	received_seq_first_：所收到的第一个包的seq
    7. 	payload_bytes：所收到的包中payload部分字节总数
    8. 	*/
    9.     if (received_seq_first_ == 0 && receive_counters_.transmitted.payload_bytes == 0) 
    10. 	{
    11.       // We have not received anything.
    12.       return false;
    13.     }
    14.  
    15. 	/* 不重新进行丢包统计 */
    16.     if (!reset) 
    17. 	{
    18. 	  /* 收到的包总数 与 重传报数 之差 */
    19.       if (last_report_inorder_packets_ == 0) 
    20. 	  {
    21.         // No report.
    22.         return false;
    23.       }
    24.  
    25.       // 直接使用上一次的report
    26.       *statistics = last_reported_statistics_;
    27.       return true;
    28.     }
    29.  
    30. 	// 丢包统计
    31.     *statistics = CalculateRtcpStatistics();
    32.   }
    33.  
    34.   NotifyRtcpCallback();
    35.  
    36.   return true;
    37. }

    2、丢包统计

    丢包率 = 255 * 丢包数 / 预期收到的包总数

    丢包数：期望收到的包总数 - 实际收到的包总数

    期望收到的包总数 = 当前收到的最新包seq - 截止到上一次report时收到的最新包seq

    实际收到的包总数 = 正常包总数 + 重传包总数

    正常包总数（不包括重传包）= 截止到目前收到的包总数与重传包总数之差 - 截止到上一次report时收到的包总数与重传包总数之差

    重传包数 = 截止到目前收到的重传包总数 - 截止到上一次report时收到的重传包总数

    1. RtcpStatistics StreamStatisticianImpl::CalculateRtcpStatistics() 
    2. {
    3.   RtcpStatistics stats;
    4.  
    5.   // 第一次进行统计
    6.   if (last_report_inorder_packets_ == 0) 
    7.   {
    8. 	// 设置截止到上一次report时，收到的最新包
    9.     // First time we send a report.
    10.     last_report_seq_max_ = received_seq_first_ - 1;
    11.   }
    12.  
    13.   /*
    14.   计算从上一次report到当前这段时间内，预期收到的包总数
    15.   期望收到的包总数 = 当前收到的最新包seq - 截止到上一次report时收到的最新包seq
    16.   */
    17.   uint16_t exp_since_last = (received_seq_max_ - last_report_seq_max_);
    18.  
    19.   // 遇到seq回绕
    20.   if (last_report_seq_max_ > received_seq_max_) 
    21.   {
    22.     exp_since_last = 0;
    23.   }
    24.  
    25.   /*
    26.   计算从上一次report到当前这段时间内，所收到的包数（不包括重传包）
    27.   包数（不包括重传包）= 截止到目前收到的包总数与重传包总数之差 - 截止到上一次report时收到的包总数与重传包总数之差
    28.   */
    29.   uint32_t rec_since_last =
    30.       (receive_counters_.transmitted.packets -
    31.        receive_counters_.retransmitted.packets) - last_report_inorder_packets_;
    32.  
    33.   // With NACK we don't know the expected retransmissions during the last
    34.   // second. We know how many "old" packets we have received. We just count
    35.   // the number of old received to estimate the loss, but it still does not
    36.   // guarantee an exact number since we run this based on time triggered by
    37.   // sending of an RTP packet. This should have a minimum effect.
    39.   // With NACK we don't count old packets as received since they are
    40.   // re-transmitted. We use RTT to decide if a packet is re-ordered or
    41.   // re-transmitted.
    42.  
    43.   /*
    44.   计算从上一次report到当前这段时间内，收到的重传包总数
    45.   重传包数 = 截止到目前收到的重传包总数 - 截止到上一次report时收到的重传包总数
    46.   */
    47.   uint32_t retransmitted_packets = receive_counters_.retransmitted.packets - last_report_old_packets_;
    48.  
    49.   /*
    50.   计算从上一次report到当前这段时间内，实际收到的包总数
    51.   实际收到的包总数 = 正常包总数 + 重传包总数
    52.   */
    53.   rec_since_last += retransmitted_packets;
    54.  
    55.   // 计算丢包数：期望收到的包总数 - 实际收到的包总数
    56.   int32_t missing = 0;
    57.   if (exp_since_last > rec_since_last) 
    58.   {
    59.     missing = (exp_since_last - rec_since_last);
    60.   }
    61.  
    62.   /*
    63.   计算丢包率
    64.   丢包率 = 255 * 丢包数 / 预期收到的包总数
    65.   255表示100%丢包
    66.   */
    67.   uint8_t local_fraction_lost = 0;
    68.   if (exp_since_last) 
    69.   {
    70.     local_fraction_lost = static_cast<uint8_t>(255 * missing / exp_since_last);
    71.   }
    72.   stats.fraction_lost = local_fraction_lost;
    73.  
    74.   // 累计到目前为止的丢包总数
    75.   cumulative_loss_ += missing;
    76.   stats.cumulative_lost = cumulative_loss_;
    77.  
    78.   /*
    79.   扩展最近收到的最新包seq
    80.   received_seq_wraps_：发生seq回绕的次数
    81.   */
    82.   stats.extended_max_sequence_number = (received_seq_wraps_ << 16) + received_seq_max_;
    83.  
    84.   // 抖动
    85.   // Note: internal jitter value is in Q4 and needs to be scaled by 1/16.
    86.   stats.jitter = jitter_q4_ >> 4;
    88.   // Store this report.
    89.   last_reported_statistics_ = stats;
    90.  
    91.   // 截止到目前为止，收到的包总数与重传包总数之差
    92.   last_report_inorder_packets_ = receive_counters_.transmitted.packets - receive_counters_.retransmitted.packets;
    93.  
    94.   // 记录本次report时的重传包总数、最新包seq
    95.   last_report_old_packets_ = receive_counters_.retransmitted.packets;
    96.   last_report_seq_max_ = received_seq_max_;
    97.  
    98.   return stats;
    99. }

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

  • 相关阅读:
    8/15 缩点+割点(割顶)+桥（割边）+字符串哈希
    使用 MRKL 系统跨越神经符号鸿沟
    堆体扫描点云体积计算实现思路分享
    synchronized已经不在臃肿了，放下对他的成见之初识轻量级锁
    计算机毕业设计Java在线问诊系统的设计与实现（源码+系统+mysql数据库+Lw文档）
    Nebula Studio：部署与连接
    理解HTTPS/TLS/SSL（二）可视化TLS握手过程并解密加密数据
    【excel实战】-- 批量提取批准&多重区域复制粘贴
    java中的集合框架基础-5
    【计算机组成原理】考研真题攻克与重点知识点剖析 - 第 1 篇：计算机系统概述
  • 原文地址：https://blog.csdn.net/m0_60259116/article/details/126647103