webrtc DelayManager代码研读

编程入门行业动态更新时间:2024-10-11 13:19:18

webrtc DelayManager<a href=https://www.elefans.com/category/jswz/34/1771412.html style= 代码研读"/>

webrtc DelayManager代码研读

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_20msint 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);
}