流媒体学习之路(WebRTC)——音频NackTracker优化思路（8）

流媒体学习之路(WebRTC)——音频NackTracker优化思路（8）

——
我正在的github给大家开发一个用于做实验的项目 —— github.com/qw225967/Bifrost

目标：可以让大家熟悉各类Qos能力、带宽估计能力，提供每个环节关键参数调节接口并实现一个json全配置，提供全面的可视化算法观察能力。

欢迎大家使用
——

文章目录

• 流媒体学习之路(WebRTC)——音频NackTracker优化思路（8）
• 一、NackTracker逻辑分析
• • 1.1 设计思路
  • 1.2 代码
• 二、优化思路
• 三、测试
• 四、总结

  在讲具体内容之前插一句嘴，从GCC分析（3）开始，我们将针对GCC的实现细节去分析它设计的原理，让我们理解这些类存在的意义，不再带大家去串具体的流程了。

一、NackTracker逻辑分析

1.1 设计思路

  NackTracker是WebRTC根据NetEq逻辑设计的Nack逻辑，相比于视频的重传，音频考虑的问题相对更多一些。（本文的音频NackTracker逻辑来源于WebRTC105版本）

//
// The NackTracker class keeps track of the lost packets, an estimate of
// time-to-play for each packet is also given.
//
// Every time a packet is pushed into NetEq, LastReceivedPacket() has to be
// called to update the NACK list.
//
// Every time 10ms audio is pulled from NetEq LastDecodedPacket() should be
// called, and time-to-play is updated at that moment.
//
// If packet N is received, any packet prior to N which has not arrived is
// considered lost, and should be labeled as "missing" (the size of
// the list might be limited and older packet eliminated from the list).
//
// The NackTracker class has to know about the sample rate of the packets to
// compute time-to-play. So sample rate should be set as soon as the first
// packet is received. If there is a change in the receive codec (sender changes
// codec) then NackTracker should be reset. This is because NetEQ would flush
// its buffer and re-transmission is meaning less for old packet. Therefore, in
// that case, after reset the sampling rate has to be updated.
//
// Thread Safety
// =============
// Please note that this class in not thread safe. The class must be protected
// if different APIs are called from different threads.
//

  上面是NackTracker注释的设计思路，意思是：
  1.统计丢失的数据包，并给出每个数据包播放的估计时间；
  2.每次数据进入NetEq时，都会调用 LastReceivedPacket() 更新 NackList；
  3.每次从NetEq队列提取10ms的音频，都需要调用LastDecodedPacket()，更新播放时间记录；
  4.如果接收到数据包N，则在N之前尚未到达的任何数据包都被视为丢失，并应标记为“丢失”（列表的大小可能受到限制，旧的数据包将从列表中删除——这里记录的默认值是500）。
  5.NackTracker类必须知道数据包的采样率才能计算播放时间。因此，一旦接收到第一个数据包，就应该设置采样率。如果接收编解码器发生变化（发送方更改编解码器），则应重置NackTracker。这是因为NetEQ会清空其缓冲区，而重新传输对旧数据包来说意义不大。因此，在这种情况下，在重置之后，必须更新采样率。

1.2 代码

void NackTracker::UpdateLastReceivedPacket(uint16_t sequence_number,
uint32_t timestamp) {
// Just record the value of sequence number and timestamp if this is the
// first packet.
// 记录第一个数据包接收信息
if (!any_rtp_received_) {
sequence_num_last_received_rtp_ = sequence_number;
timestamp_last_received_rtp_ = timestamp;
any_rtp_received_ = true;
// If no packet is decoded, to have a reasonable estimate of time-to-play
// use the given values.
if (!any_rtp_decoded_) {
sequence_num_last_decoded_rtp_ = sequence_number;
timestamp_last_decoded_rtp_ = timestamp;
}
return;
}
// 序号已接到直接返回
if (sequence_number == sequence_num_last_received_rtp_)
return;
// Received RTP should not be in the list.
nack_list_.erase(sequence_number);
// If this is an old sequence number, no more action is required, return.
// 如果是旧数据直接返回
if (IsNewerSequenceNumber(sequence_num_last_received_rtp_, sequence_number))
return;
// 更新丢包率估计
UpdatePacketLossRate(sequence_number - sequence_num_last_received_rtp_ - 1);
// 更新nack列表
UpdateList(sequence_number, timestamp);
sequence_num_last_received_rtp_ = sequence_number;
timestamp_last_received_rtp_ = timestamp;
// 尝试清除队列到当前最大限制
LimitNackListSize();
}
// 这里的逻辑是个指数滤波器
// 指数滤波器是个低通滤波器，主要是削弱高频信号：
// y(k) = a * y(k-1) +  (1-a) * x(k)
// a就是下面的alpha_q30，这个值在：0-1之间，通常是0.8 ~ 0.99，这里配置给出0.996
void NackTracker::UpdatePacketLossRate(int packets_lost) {
// 计算alpha值，用默认值换算后：1069446856
const uint64_t alpha_q30 = (1 << 30) * config_.packet_loss_forget_factor;
// Exponential filter.
// 进行指数滤波留下丢包的低通值
packet_loss_rate_ = (alpha_q30 * packet_loss_rate_) >> 30;
for (int i = 0; i < packets_lost; ++i) {
packet_loss_rate_ =
((alpha_q30 * packet_loss_rate_) >> 30) + ((1 << 30) - alpha_q30);
}
}
// 这个函数根据最新的包序号更新丢包值
void NackTracker::UpdateList(uint16_t sequence_number_current_received_rtp,
uint32_t timestamp_current_received_rtp) {
// 序号连续直接返回
if (!IsNewerSequenceNumber(sequence_number_current_received_rtp,
sequence_num_last_received_rtp_ + 1)) {
return;
}
RTC_DCHECK(!any_rtp_decoded_ ||
IsNewerSequenceNumber(sequence_number_current_received_rtp,
sequence_num_last_decoded_rtp_));
// 更新采样的包周期
absl::optional<int> samples_per_packet = GetSamplesPerPacket(
sequence_number_current_received_rtp, timestamp_current_received_rtp);
if (!samples_per_packet) {
return;
}
// 更新丢包到nacklist
for (uint16_t n = sequence_num_last_received_rtp_ + 1;
IsNewerSequenceNumber(sequence_number_current_received_rtp, n); ++n) {
uint32_t timestamp = EstimateTimestamp(n, *samples_per_packet);
NackElement nack_element(TimeToPlay(timestamp), timestamp);
nack_list_.insert(nack_list_.end(), std::make_pair(n, nack_element));
}
}
// 需要根据采样率估计出每个包的周期
absl::optional<int> NackTracker::GetSamplesPerPacket(
uint16_t sequence_number_current_received_rtp,
uint32_t timestamp_current_received_rtp) const {
uint32_t timestamp_increase =
timestamp_current_received_rtp - timestamp_last_received_rtp_;
uint16_t sequence_num_increase =
sequence_number_current_received_rtp - sequence_num_last_received_rtp_;
int samples_per_packet = timestamp_increase / sequence_num_increase;
if (samples_per_packet == 0 ||
samples_per_packet > kMaxPacketSizeMs * sample_rate_khz_) {
// Not a valid samples per packet.
return absl::nullopt;
}
return samples_per_packet;
}
// 根据周期计算时间戳
uint32_t NackTracker::EstimateTimestamp(uint16_t sequence_num,
int samples_per_packet) {
uint16_t sequence_num_diff = sequence_num - sequence_num_last_received_rtp_;
return sequence_num_diff * samples_per_packet + timestamp_last_received_rtp_;
}
// 根据最大包限制清除包
void NackTracker::LimitNackListSize() {
uint16_t limit = sequence_num_last_received_rtp_ -
static_cast<uint16_t>(max_nack_list_size_) - 1;
nack_list_.erase(nack_list_.begin(), nack_list_.upper_bound(limit));
}

  上述逻辑中有几个点需要思考一下：
  1.为什么使用指数滤波器对丢包率进行低通滤波？
  2.为什么Nack队列需要记录时间戳信息？

  答：首先，packet_loss_rate_是用于做最大等待时间估计的，这个最大等待时间估计用于判断是否需要请求重传的判断。

// We don't erase elements with time-to-play shorter than round-trip-time.
std::vector<uint16_t> NackTracker::GetNackList(int64_t round_trip_time_ms) {
RTC_DCHECK_GE(round_trip_time_ms, 0);
std::vector<uint16_t> sequence_numbers;
// rtt异常兜底
if (round_trip_time_ms == 0) {
if (config_.require_valid_rtt) {
return sequence_numbers;
} else {
round_trip_time_ms = config_.default_rtt_ms;
}
}
// 丢包率异常，大于1直接返回
if (packet_loss_rate_ >
static_cast<uint32_t>(config_.max_loss_rate * (1 << 30))) {
return sequence_numbers;
}
// The estimated packet loss is between 0 and 1, so we need to multiply by 100
// here.
// 根据丢包率计算最大等待时间
int max_wait_ms =
100.0 * config_.ms_per_loss_percent * packet_loss_rate_ / (1 << 30);
// 重传包放入队列
for (NackList::const_iterator it = nack_list_.begin(); it != nack_list_.end();
++it) {
// 计算当前时间戳和丢包时间戳的差值
int64_t time_since_packet_ms =
(timestamp_last_received_rtp_ - it->second.estimated_timestamp) /
sample_rate_khz_;
// 丢包数据播放时间超过rtt || 接到数据的差值 + rtt 小于最大等待时间 则进行重传请求
if (it->second.time_to_play_ms > round_trip_time_ms ||
time_since_packet_ms + round_trip_time_ms < max_wait_ms)
sequence_numbers.push_back(it->first);
}
// 配置开启，仅进行单次Nack请求，则清除队列
if (config_.never_nack_multiple_times) {
nack_list_.clear();
}
return sequence_numbers;
}

  从上述的代码中可以看到，音频的重传限制主要有两个：
  1.播放时间大于rtt——（代表这个重传是有意义的，这个数据请求重传能在一个rtt重传回来则可以赶上播放，不增加延迟）；
  2.等待时间+rtt 小于最大等待时间——最大等待时间的计算：

// 每次丢包增加等待的时长：ms_per_loss_percent = 20
// 计算alpha衰减因子：packet_loss_forget_factor = 0.996
// 假设有7个丢包，那么根据上述运算逻辑：
int ms_per_loss_percent = 20;
uint32_t packet_loss_rate_ = 0;
double packet_loss_forget_factor = 0.996;
const uint64_t alpha_q30 = (1 << 30) * packet_loss_forget_factor;
packet_loss_rate_ = (alpha_q30 * packet_loss_rate_) >> 30;
for (int i = 0; i < 7; ++i) {
packet_loss_rate_ =
((alpha_q30 * packet_loss_rate_) >> 30) + ((1 << 30) - alpha_q30);
}
int max_wait_ms =
100.0 * ms_per_loss_percent * packet_loss_rate_ / (1 << 30);
// 那么 max_wait_ms 计算得到为 55ms。

  随着丢包个数的增加，最大等待时间也会增长。下面画了一张最大等待时间和每次计算丢包个数的曲线图：

  上面的图显示，随着丢包数不断增加，等待的时间增长也变得缓慢，即使把连续丢包数增加到199个（这个连续丢包指的是每次接到的数据跳了199个，在现实的网络环境中，随机丢包基本不可能出现这种情况，除非完全堵死）也只是增加到了1099ms。因此，音频的nack相比视频来说更注重实时性，因为很多时候丢一两个包，整体的沟通也不会有太大的影响。

二、优化思路

  在实时传输中，我们需要根据应用的场景进行针对性调整。例如：我们常常看到导弹的引导画面会出现各种花屏的情况，在这种实时性要求较高，体验要求低的战场场景下，那么多重传并没有意义。相反，在延迟较大的CDN直播场景下，实时要求低，质量要求高的情况下重传来保证整体的质量就更有必要。因此，我们可以思考一下，在我们各自的使用场景中是否需要提高Nack重传的效率。
  基于上面的理解，我们对NackTracker进行分析：

  接收RTP：

  发送Nack：

  限制发送Nack的位置就是我们可以做手脚的地方：
  1.调整播放时间和RTT的比，想速度变快就把RTT变为 RTT/2 或者 RTT/4，想速度变慢就把RTT变为2RTT 或者 3RTT；
  2.在增加重传速度时，也可以适当的调长最大等待时间。
    可以增加每多一个丢包等待的时间；也可以调整平滑值来增大丢包率的平滑值。

  struct Config {
Config();
// The exponential decay factor used to estimate the packet loss rate.
// 这个值会影响丢包率的平滑值
double packet_loss_forget_factor = 0.996;
// How many additional ms we are willing to wait (at most) for nacked
// packets for each additional percentage of packet loss.
// 这个值是每多一个丢包，多等待的时间值
int ms_per_loss_percent = 20;
// If true, never nack packets more than once.
// 这个值影响是否第二次重传
bool never_nack_multiple_times = false;
// Only nack if the RTT is valid.
// 这个值代表只有在RTT生效时发送Nack
bool require_valid_rtt = false;
// Default RTT to use unless `require_valid_rtt` is set.
// 默认RTT值
int default_rtt_ms = 100;
// Do not nack if the loss rate is above this value.
// 最大丢包率限制
double max_loss_rate = 1.0;
};

三、测试

  本次测试中间通过了进行过上行Nack调整的Mediasoup服务器。在原先的测试中我们发现，当上行存在小丢包，下行大延迟的网络环境中，音频会产生很大的丢包，相比我们调整过的Nack视频确没有任何丢包产生，于是我们进行了以下调整，使音频与视频效果对其：
  1.调整重传限制为，待播放时间差 大于 rtt/2 就进行重传；
  2.调整等待时间为 2倍的最大等待（根据计算，在延迟600ms时，大部分音频的重传都超过了最大等待时间）。

进行测试：

四、总结

  音频NackTracker的逻辑与视频NackRequest有相似的地方，但是相比多了播放时间以及丢包的等待估计，因此限制更多。在同样的模拟环境下，原NackTracker的逻辑丢包明显。这与音频的特点有关，音频可以合理的丢弃数据并不会明显的影响听感，但是视频少一个数据就无法组成完整的图像。因此WebRTC为了保证实时性，增加了播放时间对比以及丢包参考，如果想要保证Nack的效果与视频一致，那么也需要调整一下它的频率和最大限制。但这不意味着效果更好，因为测试发现它的带宽消耗相对高了不少，因此我们需要结合场景考虑。