webrtc研究-remb协议分析

分析入口 webrtc/ideo/vie_remb.cc

void VieRemb::OnReceiveBitrateChanged(const std::vector<uint32_t>& ssrcs,        uint32_t bitrate) {        RtpRtcp* sender = nullptr;        {            rtc::CritScope lock(&list_crit_);            // If we already have an estimate, check if the new total estimate is below            // kSendThresholdPercent of the previous estimate.            if (last_send_bitrate_ > 0) {                uint32_t new_remb_bitrate = last_send_bitrate_ - bitrate_ + bitrate;                if (new_remb_bitrate < kSendThresholdPercent * last_send_bitrate_ / 100) {                    // The new bitrate estimate is less than kSendThresholdPercent % of the                    // last report. Send a REMB asap.                    last_remb_time_ = clock_->TimeInMilliseconds() - kRembSendIntervalMs;                }            }            bitrate_ = bitrate;            // Calculate total receive bitrate estimate.            int64_t now = clock_->TimeInMilliseconds();            if (now - last_remb_time_ < kRembSendIntervalMs) {                return;            }            last_remb_time_ = now;            if (ssrcs.empty() || receive_modules_.empty()) {                return;            }            // Send a REMB packet./*                  if (!rtcp_sender_.empty()) {                sender = rtcp_sender_.front();            }            else {                sender = receive_modules_.front();            }*/                      if (!receive_modules_.empty()) {                sender = receive_modules_.front();            }            else {                sender = rtcp_sender_.front();            }            last_send_bitrate_ = bitrate_;        }        if (sender) {            sender->SetREMBData(bitrate_, ssrcs);        }    }}  // namespace webrtc

在改新版webrtc时， 原有的tmmbr/tmmbn改为remb，因为业务需求修改了服务器逻辑，再使用时，发现remb的请求码率一直上不去，分析原因，找个函数作为入口，分析remb的生成计算
调用顺序
remote_bitrate_estimator_single_stream.cc
void RemoteBitrateEstimatorSingleStream::Process()
之后
remote_bitrate_estimator_single_stream.cc
void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms)
之后
vie_remb.cc
void VieRemb::OnReceiveBitrateChanged(const std::vector& ssrcs, uint32_t bitrate)

好吧，发现是在这条道上产生的，之后发现在
remote_bitrate_estimator_single_stream.cc
void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms)

void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms) {    ......  double mean_noise_var = sum_var_noise /      static_cast<double>(overuse_detectors_.size());  const RateControlInput input(bw_state,                               incoming_bitrate_.Rate(now_ms),                               mean_noise_var);  remote_rate_->Update(&input, now_ms);  uint32_t target_bitrate = remote_rate_->UpdateBandwidthEstimate(now_ms);  if (remote_rate_->ValidEstimate()) {    process_interval_ms_ = remote_rate_->GetFeedbackInterval();    std::vector<uint32_t> ssrcs;    GetSsrcs(&ssrcs);    observer_->OnReceiveBitrateChanged(ssrcs, target_bitrate);  }}

码率在此计算？

  const RateControlInput input(bw_state,                               incoming_bitrate_.Rate(now_ms),                               mean_noise_var);

进入 incoming_bitrate_.Rate(now_ms)

代码进入，期待解开真相。。。这TMD都是些啥啥啊
rate_statistics.cc

rtc::Optional<uint32_t> RateStatistics::Rate(int64_t now_ms) const {  // Yeah, this const_cast ain't pretty, but the alternative is to declare most  // of the members as mutable...  const_cast<RateStatistics*>(this)->EraseOld(now_ms);  // If window is a single bucket or there is only one sample in a data set that  // has not grown to the full window size, treat this as rate unavailable.  int64_t active_window_size = now_ms - oldest_time_ + 1;  if (num_samples_ == 0 || active_window_size <= 1 ||      (num_samples_ <= 1 && active_window_size < current_window_size_ms_)) {    return rtc::Optional<uint32_t>();  }  float scale = scale_ / active_window_size;  return rtc::Optional<uint32_t>(      static_cast<uint32_t>(accumulated_count_ * scale + 0.5f));}

scale_ 是固定的8000
accumulated_count_ * scale + 0.5f
accumulated_count_ *scale_ /(now_ms - oldest_time_ + 1) + 0.5f
如果没有推测错 accumulated_count_ 就是在now_ms - oldest_time_时间接受到的字节数 单位KB，
然后计算出单位时间可以接受的带宽， 单位bit

继续顺藤摸瓜， 验证推测

void RateStatistics::Update(size_t count, int64_t now_ms) {  if (now_ms < oldest_time_) {    // Too old data is ignored.    return;  }  EraseOld(now_ms);  // First ever sample, reset window to start now.  if (!IsInitialized())    oldest_time_ = now_ms;  uint32_t now_offset = static_cast<uint32_t>(now_ms - oldest_time_);  RTC_DCHECK_LT(now_offset, max_window_size_ms_);  uint32_t index = oldest_index_ + now_offset;  if (index >= max_window_size_ms_)    index -= max_window_size_ms_;  buckets_[index].sum += count;  ++buckets_[index].samples;  accumulated_count_ += count;  ++num_samples_;}

看到accumulated_count_ += count;

调用顺序
rtp_stream_receiver.cc
bool RtpStreamReceiver::DeliverRtp(const uint8_t* rtp_packet,
size_t rtp_packet_length,
const PacketTime& packet_time)
之后
congestion_controller.cc
void IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header)
之后
remote_bitrate_estimator_single_stream.cc
void RemoteBitrateEstimatorSingleStream::IncomingPacket
之后
rate_statistics.cc
void RateStatistics::Update(size_t count, int64_t now_ms)
简单理解 就是接收到数据记个数
？？？remb就是接受到的带宽？？？，是不是哪里看漏了