DelayManager代码研读
DelayManager利用方直图，统计出当前的延迟并，算出现在的应提供的buffer大小。
DelayManager通过调用Update更新包的延迟统计，并计算出target_level_；
调用BufferLimits根据target_level_获取最大最小缓存（lower_limit, higher_limit）；
通过最大，最小缓存生成dsp的相关指令；
absl::optional Update(uint16_t sequence_number, uint32_t timestamp, int sample_rate_hz）分析
参数：
sequence_number：接收到的rtp包的序列号。
timestamp：包的时间戳，注意这个时间戳是按照总共多少帧来给的，就是前后两个时间戳相减算出的是有多少帧，需要除以帧率才能换算成时间
sample_rate_hz：声音的采样率。
算法代码：（去除了异常处理）
absl::optional<int> DelayManager::Update(uint16_t sequence_number,
uint32_t timestamp,
int sample_rate_hz) {
//第一次进入
if (!first_packet_received_) {
// Prepare for next packet arrival.
packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
last_seq_no_ = sequence_number;
last_timestamp_ = timestamp;
first_packet_received_ = true;
return absl::nullopt;
}
//计算两个包的间隔时长，用ms表示，这个是包的发送时的时间间隔。
// Calculate timestamps per packet and derive packet length in ms.
int64_t packet_len_samp =
static_cast<uint32_t>(timestamp - last_timestamp_) /
static_cast<uint16_t>(sequence_number - last_seq_no_);
packet_len_ms =
rtc::saturated_cast<int>(1000 * packet_len_samp / sample_rate_hz);
bool reordered = false;
absl::optional<int> relative_delay;
if (packet_len_ms > 0) {
// Cannot update statistics unless |packet_len_ms| is valid.
//接收端真实的收到包的时间
// Inter-arrival time (IAT) in integer "packet times" (rounding down). This
// is the value added to the inter-arrival time histogram.
int iat_ms = packet_iat_stopwatch_->ElapsedMs();
//接收时间减去发送的时间，就是iat延迟。
int iat_delay = iat_ms - packet_len_ms;
//进行统计，将包的延迟放入delay_history_， 具体看代码
UpdateDelayHistory(iat_delay, timestamp, sample_rate_hz);
//统计两秒内发送端所有包的延迟
relative_delay = CalculateRelativePacketArrivalDelay();
//kBucketSizeMs固定为20ms，也就是方直图的index间隔为20ms一个。索引index大小100个（方直图算法请看方直图算法博客）
const int index = relative_delay.value() / kBucketSizeMs;
if (index < histogram_->NumBuckets()) {
// Maximum delay to register is 2000 ms.
histogram_->Add(index);
}
//通过方直图统计出当前的target_level_，就是现在的方直图统计的延迟，用Q8表示的。
// Calculate new |target_level_| based on updated statistics.
target_level_ = CalculateTargetLevel();
//将target_level_限制在
//effective_minimum_delay_ms_ ，
//maximum_delay_ms_，
//max_buffer_packets_q8
//所规定的范围内
LimitTargetLevel();
} // End if (packet_len_ms > 0).
if (enable_rtx_handling_ && reordered &&
num_reordered_packets_ < kMaxReorderedPackets) {
++num_reordered_packets_;
return relative_delay;
}
num_reordered_packets_ = 0;
// Prepare for next packet arrival.
packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
last_seq_no_ = sequence_number;
last_timestamp_ = timestamp;
return relative_delay; //返回两秒内的延迟统计
}
void DelayManager::BufferLimits(int target_level, int* lower_limit, int* higher_limit)分析
依据target_level_ 获取 lower_limit, higher_limit
// Note that |low_limit| and |higher_limit| are not assigned to
// |minimum_delay_ms_| and |maximum_delay_ms_| defined by the client of this
// class. They are computed from |target_level| in Q8 and used for decision
// making.
void DelayManager::BufferLimits(int target_level,
int* lower_limit,
int* higher_limit) const {
if (!lower_limit || !higher_limit) {
RTC_LOG_F(LS_ERROR) << "NULL pointers supplied as input";
assert(false);
return;
}
//最小的限制 target_level的3/4，当target_level的1/4大于85ms（kDecelerationTargetLevelOffsetMs==85）时，使用
//target_level - kDecelerationTargetLevelOffsetMs/packet_len_ms_。
// |target_level| is in Q8 already.
*lower_limit = (target_level * 3) / 4;
if (packet_len_ms_ > 0) {
*lower_limit =
std::max(*lower_limit, target_level - kDecelerationTargetLevelOffsetMs /
packet_len_ms_);
}
//最大限制就是target_level，如果target_level的1/4小于20ms，就直接lower_limit + window_20ms
int window_20ms = 0x7FFF; // Default large value for legacy bit-exactness.
if (packet_len_ms_ > 0) {
window_20ms = (20 << 8) / packet_len_ms_;
}
// |higher_limit| is equal to |target_level|, but should at
// least be 20 ms higher than |lower_limit|.
*higher_limit = std::max(target_level, *lower_limit + window_20ms);
}
void DelayManager::UpdateDelayHistory(int iat_delay_ms,
uint32_t timestamp,
int sample_rate_hz) {
PacketDelay delay;
delay.iat_delay_ms = iat_delay_ms;
delay.timestamp = timestamp;
delay_history_.push_back(delay);
//kMaxHistoryMs 是固定值2000,也就是2s，timestamp是包的时间戳，又发送端打上的时间戳，delay_history_保存的是发送端2s内发送的包延迟。
while (timestamp - delay_history_.front().timestamp >
static_cast<uint32_t>(kMaxHistoryMs * sample_rate_hz / 1000)) {
delay_history_.pop_front();
}
}
统计delay_history_所有包的延迟
int DelayManager::CalculateRelativePacketArrivalDelay() const {
// This effectively calculates arrival delay of a packet relative to the
// packet preceding the history window. If the arrival delay ever becomes
// smaller than zero, it means the reference packet is invalid, and we
// move the reference.
int relative_delay = 0;
for (const PacketDelay& delay : delay_history_) {
relative_delay += delay.iat_delay_ms;
relative_delay = std::max(relative_delay, 0);
}
return relative_delay;
}
int DelayManager::CalculateTargetLevel() {
int limit_probability = histogram_quantile_;
int bucket_index = histogram_->Quantile(limit_probability);
int target_level = 1;
if (packet_len_ms_ > 0) {
target_level += bucket_index * kBucketSizeMs / packet_len_ms_;
}
base_target_level_ = target_level;
// Sanity check. |target_level| must be strictly positive.
target_level = std::max(target_level, 1);
// Scale to Q8 and assign to member variable.
target_level_ = target_level << 8;
return target_level_;
}
// Enforces upper and lower limits for |target_level_|. The upper limit is
// chosen to be minimum of i) 75% of |max_packets_in_buffer_|, to leave some
// headroom for natural fluctuations around the target, and ii) equivalent of
// |maximum_delay_ms_| in packets. Note that in practice, if no
// |maximum_delay_ms_| is specified, this does not have any impact, since the
// target level is far below the buffer capacity in all reasonable cases.
// The lower limit is equivalent of |effective_minimum_delay_ms_| in packets.
// We update |least_required_level_| while the above limits are applied.
// TODO(hlundin): Move this check to the buffer logistics class.
void DelayManager::LimitTargetLevel() {
if (packet_len_ms_ > 0 && effective_minimum_delay_ms_ > 0) {
int minimum_delay_packet_q8 =
(effective_minimum_delay_ms_ << 8) / packet_len_ms_;
target_level_ = std::max(target_level_, minimum_delay_packet_q8);
}
if (maximum_delay_ms_ > 0 && packet_len_ms_ > 0) {
int maximum_delay_packet_q8 = (maximum_delay_ms_ << 8) / packet_len_ms_;
target_level_ = std::min(target_level_, maximum_delay_packet_q8);
}
// Shift to Q8, then 75%.;
int max_buffer_packets_q8 =
static_cast<int>((3 * (max_packets_in_buffer_ << 8)) / 4);
target_level_ = std::min(target_level_, max_buffer_packets_q8);
// Sanity check, at least 1 packet (in Q8).
target_level_ = std::max(target_level_, 1 << 8);
}
成员变量作用分析
packet_len_ms_ ： 每一个包的长度，有30ms，20ms。
max_packets_in_buffer_ : buffer中最多包的个数，它的3/4转成ms为target_level的最大值。
packet_iat_stopwatch_ ：tick_timer_->GetNewStopwatch()得到， 标记一次ticktimer的开始。
tick_timer_的用法：
packet_iat_stopwatch_ = tick_timer_.GetNewStopwatch()；开始一次tick_timer
tick_timer_.Increment()；比如10ms一次tick，50ms就需要调用5次，来进行计数
int iat_ms = packet_iat_stopwatch_->ElapsedMs()；调用多少次Increment()就过了多少时间，如果调用5次，就是5*10=50ms
base_target_level_ ： 是10进制的方直图计算值
target_level_ : 使用Q8表示，base_target_level_进过LimitTargetLevel限制后的值
maximum_delay_ms_ ： 最大的延迟，在LimitTargetLevel对target_level_进行限制
minimum_delay_ms_ ： 最小的延迟
base_minimum_delay_ms_： 基本最小延迟，需要再[0, 10000]之间
effective_minimum_delay_ms_ ： minimum_delay_ms_ 和 base_minimum_delay_ms_ 中较大的值等于该值，查看void DelayManager::UpdateEffectiveMinimumDelay()中的计算方法。