webrtc-RemoteEstimatorProxy

RemoteEstimatorProxy
接收端使用RemoteEstimatorProxy，统计接收的报信息，然后进行feedback包的构建，并且触发发送。 继承于Module，有Process处理循环

1. 数据输入部分

    void RemoteEstimatorProxy::IncomingPacket(int64_t arrival_time_ms,
                                              size_t payload_size,
                                              const RTPHeader& header) {
      if (!header.extension.hasTransportSequenceNumber) {
        //是否有效的transportCC包，
        LOG(LS_WARNING) << "RemoteEstimatorProxy: Incoming packet "
                           "is missing the transport sequence number extension!";
        return;
      }
   
      rtc::CritScope cs(&lock_);
      media_ssrc_ = header.ssrc;
    
      OnPacketArrival(header.extension.transportSequenceNumber, arrival_time_ms);
    }
   
   
    void RemoteEstimatorProxy::OnPacketArrival(uint16_t sequence_number,
                                               int64_t arrival_time) {
      //消除seq回绕问题，
      int64_t seq = unwrapper_.Unwrap(sequence_number);
      if (seq > window_start_seq_ + 0xFFFF / 2) {
        return;
      }
    
      //查找window_start_seq_位置
      if (packet_arrival_times_.lower_bound(window_start_seq_) ==
          packet_arrival_times_.end()) {
        // Start new feedback packet, cull old packets.
    	  //删除已经老化的数据
        for (auto it = packet_arrival_times_.begin();
             it != packet_arrival_times_.end() && it->first < seq &&
             arrival_time - it->second >= kBackWindowMs;) {
          auto delete_it = it;
          ++it;
          packet_arrival_times_.erase(delete_it);
        }
      }
    
      if (window_start_seq_ == -1) {
        window_start_seq_ = sequence_number;
      } else if (seq < window_start_seq_) {
        window_start_seq_ = seq;
      }
    
      //保存数据，用于Process构建Feedback
      if (packet_arrival_times_.find(seq) != packet_arrival_times_.end())
        return;
    
      packet_arrival_times_[seq] = arrival_time;
    }
   

2. 数据输出，构建发送fb包

    void RemoteEstimatorProxy::Process() {
      last_process_time_ms_ = clock_->TimeInMilliseconds();
    
      bool more_to_build = true;
      while (more_to_build) {
        rtcp::TransportFeedback feedback_packet;
        if (BuildFeedbackPacket(&feedback_packet)) {
          //通过PacketRouter发送 tranportCC包给发送端
          packet_router_->SendFeedback(&feedback_packet);
        } else {
          more_to_build = false;
        }
      }
    }
   
   
    //随着码率的改变，发送rtcp的间隔也相应的需要改变, 5%流量发送rtcp
    void RemoteEstimatorProxy::OnBitrateChanged(int bitrate_bps) {
      // TwccReportSize = Ipv4(20B) + UDP(8B) + SRTP(10B) +
      // AverageTwccReport(30B)
      // TwccReport size at 50ms interval is 24 byte.
      // TwccReport size at 250ms interval is 36 byte.
      // AverageTwccReport = (TwccReport(50ms) + TwccReport(250ms)) / 2
      constexpr int kTwccReportSize = 20 + 8 + 10 + 30;
      constexpr double kMinTwccRate =
          kTwccReportSize * 8.0 * 1000.0 / kMaxSendIntervalMs;
      constexpr double kMaxTwccRate =
          kTwccReportSize * 8.0 * 1000.0 / kMinSendIntervalMs;
    
      // Let TWCC reports occupy 5% of total bandwidth.
      //计算新的发送间隔，用于fb包
      rtc::CritScope cs(&lock_);
      send_interval_ms_ = static_cast<int>(0.5 + kTwccReportSize * 8.0 * 1000.0 /
          (std::max(std::min(0.05 * bitrate_bps, kMaxTwccRate), kMinTwccRate)));
    }