uint32_t AimdRateControl::ChangeBitrate(uint32_t current_bitrate_bps,
                                        uint32_t incoming_bitrate_bps,
                                        int64_t now_ms) {
  // 在调用函数update更新对应的链路状态估计，累积码率，噪声值后
  // 会将updated置位，如果没置位则不会去更新码率。
  if (!updated_) {
    return current_bitrate_bps_;
  }
  // An over-use should always trigger us to reduce the bitrate, even though
  // we have not yet established our first estimate. By acting on the over-use,
  // we will end up with a valid estimate.
  // 初始化未完成，如果不是一开始就Overuse，直接返回初始的码率即可。
  if (!bitrate_is_initialized_ && current_input_.bw_state != kBwOverusing)
    return current_bitrate_bps_;
  updated_ = false;
  // 这里对状态进行转换，这个函数是状态机状态转换函数
  // 1. Underuse总是进入Hold状态。
  // 2. Overuse总是进入Dec状态。
  // 3. Normal状态维持，除非当前在Hold状态，此时会进入Inc状态。
  ChangeState(current_input_, now_ms);
  // Calculated here because it's used in multiple places.
  const float incoming_bitrate_kbps = incoming_bitrate_bps / 1000.0f;
  // Calculate the max bit rate std dev given the normalized
  // variance and the current incoming bit rate.
  const float std_max_bit_rate = sqrt(var_max_bitrate_kbps_ *
                                      avg_max_bitrate_kbps_);
  switch (rate_control_state_) {
	// 保持状态不更新码率
    case kRcHold:
      break;
    case kRcIncrease:
	  // 三个状态，在最大值附近，超过最大值，比最大值高到不知道哪里去
	  // 最大均值已初始化，且当前码率高于最大值加上三倍方差，此时进入
	  // 比最大值高到不知道哪里去的状态，同时认为这个均值并不是很好使，复位。
	  // Above声明了，但是没有找到相应调用点。
      if (avg_max_bitrate_kbps_ >= 0 &&
          incoming_bitrate_kbps >
              avg_max_bitrate_kbps_ + 3 * std_max_bit_rate) {
        ChangeRegion(kRcMaxUnknown);
        avg_max_bitrate_kbps_ = -1.0;
      }
	  // 
      if (rate_control_region_ == kRcNearMax) {
        // Approximate the over-use estimator delay to 100 ms.
		// 已经接近最大值了，此时增长需谨慎，加性增加。
        const int64_t response_time = rtt_ + 100;
        uint32_t additive_increase_bps = AdditiveRateIncrease(
            now_ms, time_last_bitrate_change_, response_time);
        current_bitrate_bps += additive_increase_bps;
      } else {
		// 由于没有Above状态的使用，因此认为比最大值高到不知道哪里去的状态属于
		// 上界未定，放开手倍增码率。
        uint32_t multiplicative_increase_bps = MultiplicativeRateIncrease(
            now_ms, time_last_bitrate_change_, current_bitrate_bps);
        current_bitrate_bps += multiplicative_increase_bps;
      }
      time_last_bitrate_change_ = now_ms;
      break;
    case kRcDecrease:
      bitrate_is_initialized_ = true;
      if (incoming_bitrate_bps < min_configured_bitrate_bps_) {
		// 真的不能再低了....
        current_bitrate_bps = min_configured_bitrate_bps_;
      } else {
        // Set bit rate to something slightly lower than max
        // to get rid of any self-induced delay.
        current_bitrate_bps = static_cast<uint32_t>(beta_ *
                                                    incoming_bitrate_bps + 0.5);
        if (current_bitrate_bps > current_bitrate_bps_) {
		  // 本次速率仍然在增长
          // Avoid increasing the rate when over-using.
          if (rate_control_region_ != kRcMaxUnknown) {
			// 如果上界可靠，则将码率设置在最大均值的beta_倍处，
			// 默认的beta_为0.85，同paper。
            current_bitrate_bps = static_cast<uint32_t>(
                beta_ * avg_max_bitrate_kbps_ * 1000 + 0.5f);
          }
		  // 进行修正，和上一轮迭代的码率取小，如果上界不定
		  // 则取上一次迭代的码率值。
          current_bitrate_bps = std::min(current_bitrate_bps,
                                         current_bitrate_bps_);
        }
		// 更新过新的码率值后，认为现在已经在最大均值附近。
		// 注意，每次认为上界无效时，总会把最大均值复位
		// 这里设置完对应状态后，即使上界无效，下面总会更新一个最大均值。
        ChangeRegion(kRcNearMax);
        if (incoming_bitrate_kbps < avg_max_bitrate_kbps_ -
            3 * std_max_bit_rate) {
		  // 当前速率小于均值较多，认为均值不可靠，复位
          avg_max_bitrate_kbps_ = -1.0f;
        }
		// 衰减状态下需要更新最大均值
        UpdateMaxBitRateEstimate(incoming_bitrate_kbps);
      }
      // Stay on hold until the pipes are cleared.
	  // 降低码率后回到HOLD状态，如果网络状态仍然不好，在Overuse仍然会进入Dec状态。
	  // 如果恢复，则不会是Overuse，会保持或增长。
      ChangeState(kRcHold);
      time_last_bitrate_change_ = now_ms;
      break;
    default:
      assert(false);
  }
  if ((incoming_bitrate_bps > 100000 || current_bitrate_bps > 150000) &&
      current_bitrate_bps > 1.5 * incoming_bitrate_bps) {
    // Allow changing the bit rate if we are operating at very low rates
    // Don't change the bit rate if the send side is too far off
    current_bitrate_bps = current_bitrate_bps_;
    time_last_bitrate_change_ = now_ms;
  }
  return current_bitrate_bps;
}

uint32_t AimdRateControl::AdditiveRateIncrease(
    int64_t now_ms, int64_t last_ms, int64_t response_time_ms) const {
  assert(response_time_ms > 0);
  double beta = 0.0;
  if (last_ms > 0) {
	// 时间间隔和RTT之比作为系数。
	// 疑问，这里的时间点是经过采样的，可能会大于rtt？
    beta = std::min((now_ms - last_ms) / static_cast<double>(response_time_ms),
                    1.0);
    if (in_experiment_)
      beta /= 2.0;
  }
  // 默认30fps，由于每个包不超过mtu，一般也就1100+，用这两个值估计每帧码率和每帧包数。
  // 并计算平均每个包的大小，最终增加的比特数不超过1000。
  double bits_per_frame = static_cast<double>(current_bitrate_bps_) / 30.0;
  double packets_per_frame = std::ceil(bits_per_frame / (8.0 * 1200.0));
  double avg_packet_size_bits = bits_per_frame / packets_per_frame;
  uint32_t additive_increase_bps = std::max(
      1000.0, beta * avg_packet_size_bits);
  return additive_increase_bps;
}

uint32_t AimdRateControl::MultiplicativeRateIncrease(
    int64_t now_ms, int64_t last_ms, uint32_t current_bitrate_bps) const {
  double alpha = 1.08;
  if (last_ms > -1) {
	// 系数计算与文档中的1.05略有不同，使用时间差作为系数，1.08作为底数。
    int time_since_last_update_ms = std::min(static_cast<int>(now_ms - last_ms),
                                             1000);
    alpha = pow(alpha,  time_since_last_update_ms / 1000.0);
  }
  uint32_t multiplicative_increase_bps = std::max(
      current_bitrate_bps * (alpha - 1.0), 1000.0);
  return multiplicative_increase_bps;
}

BandwidthUsage OveruseDetector::Detect(double offset,
                                       double ts_delta,
                                       int num_of_deltas,
                                       int64_t now_ms) {
  if (num_of_deltas < 2) {
    return kBwNormal;
  }
  const double prev_offset = prev_offset_;
  prev_offset_ = offset;
  // 更新delta T.
  const double T = std::min(num_of_deltas, 60) * offset;
  BWE_TEST_LOGGING_PLOT(1, "offset", now_ms, T);
  BWE_TEST_LOGGING_PLOT(1, "threshold", now_ms, threshold_);
  if (T > threshold_) {
	// 过载，更新对应的过载时间，过载次数统计。
    if (time_over_using_ == -1) {
      // Initialize the timer. Assume that we've been
      // over-using half of the time since the previous
      // sample.
      time_over_using_ = ts_delta / 2;
    } else {
      // Increment timer
      time_over_using_ += ts_delta;
    }
    overuse_counter_++;
	// 当且仅当总过载时间超过过载时间阈值，且其曲线仍成上升趋势(offset >= prev_offset)，
	// 进入过载状态
	// 其他场景维持原状态。
	// 判断具有一定容忍，防止因某些爆发式场景导致异常的过载判断影响网络吞吐量。
	// 过载状态解除只有T降低至阈值之下。
    if (time_over_using_ > overusing_time_threshold_ && overuse_counter_ > 1) {
      if (offset >= prev_offset) {
        time_over_using_ = 0;
        overuse_counter_ = 0;
        hypothesis_ = kBwOverusing;
      }
    }
  }
  // 清除过载相关参数
  else if (T < -threshold_) {
	// 低负载
    time_over_using_ = -1;
    overuse_counter_ = 0;
    hypothesis_ = kBwUnderusing;
  } else {
	// 正常状态
    time_over_using_ = -1;
    overuse_counter_ = 0;
    hypothesis_ = kBwNormal;
  }
  // 当过载发生时，T总是大于阈值，因此此时阈值增大。
  // 当未发生过载时，T总是小于阈值，此时阈值缩小。
  UpdateThreshold(T, now_ms);
  return hypothesis_;
}
void OveruseDetector::UpdateThreshold(double modified_offset, int64_t now_ms) {
  // 实验性质
  if (!in_experiment_)
    return;
  // 初始化
  if (last_update_ms_ == -1)
    last_update_ms_ = now_ms;
  // 修正值超过阈值可控制的最大范围，这里啥都不做，防止阈值过大。
  if (fabs(modified_offset) > threshold_ + kMaxAdaptOffsetMs) {
    // Avoid adapting the threshold to big latency spikes, caused e.g.,
    // by a sudden capacity drop.
    last_update_ms_ = now_ms;
    return;
  }
  // 第二个公式，根据修正值的绝对值和当前阈值(即i - 1时刻)比较，计算增益系数
  // 默认k_down_ = 0.00006, k_up_ = 0.004。
  // 这里两个值虽然都是正的，
  // 但是增长和减小的符号在第一个式子中的fabs(modified_offset) - threshold_
  const double k = fabs(modified_offset) < threshold_ ? k_down_ : k_up_;
  const int64_t kMaxTimeDeltaMs = 100;
  int64_t time_delta_ms = std::min(now_ms - last_update_ms_, kMaxTimeDeltaMs);
  // 公式一，阈值自适应，根据新的增益系数对阈值进行修正。
  threshold_ +=
      k * (fabs(modified_offset) - threshold_) * time_delta_ms;
  // 阈值上下限内修正。
  const double kMinThreshold = 6;
  const double kMaxThreshold = 600;
  threshold_ = std::min(std::max(threshold_, kMinThreshold), kMaxThreshold);
  last_update_ms_ = now_ms;
}

void OveruseEstimator::Update(int64_t t_delta,
                              double ts_delta,
                              int size_delta,
                              BandwidthUsage current_hypothesis) {
  const double min_frame_period = UpdateMinFramePeriod(ts_delta);
  const double t_ts_delta = t_delta - ts_delta;
  double fs_delta = size_delta;
  ++num_of_deltas_;
  if (num_of_deltas_ > kDeltaCounterMax) {
    num_of_deltas_ = kDeltaCounterMax;
  }
  // Update the Kalman filter.
  // 误差矩阵
  // 加上协方差，为配置初始化值。
  // process_noise_ Q
  // P(k) = AP(k - 1)AT + Q
  // 预测方程2
  // 2.3
  E_[0][0] += process_noise_[0];
  E_[1][1] += process_noise_[1];
  if ((current_hypothesis == kBwOverusing && offset_ < prev_offset_) ||
      (current_hypothesis == kBwUnderusing && offset_ > prev_offset_)) {
    E_[1][1] += 10 * process_noise_[1];
  }
  // h观测矩阵
  // 2.2
  const double h[2] = {fs_delta, 1.0};
  // P * h转置
  // 2.4
  const double Eh[2] = {E_[0][0]*h[0] + E_[0][1]*h[1],
                        E_[1][0]*h[0] + E_[1][1]*h[1]};
  // t_ts_delta 为 zk，residual为 zk - H * xk
  // 2.7 
  const double residual = t_ts_delta - slope_*h[0] - offset_;
  const bool in_stable_state = (current_hypothesis == kBwNormal);
  const double max_residual = 3.0 * sqrt(var_noise_);
  // We try to filter out very late frames. For instance periodic key
  // frames doesn't fit the Gaussian model well.
  if (fabs(residual) < max_residual) {
    UpdateNoiseEstimate(residual, min_frame_period, in_stable_state);
  } else {
    UpdateNoiseEstimate(residual < 0 ? -max_residual : max_residual,
                        min_frame_period, in_stable_state);
  }
  // denom = h * P * ht + R，var_noise为测量噪声协方差
  // 2.5
  const double denom = var_noise_ + h[0]*Eh[0] + h[1]*Eh[1];
  // K卡尔曼增益矩阵
  // K(k) = Eh / (HPkHT + R) 
  // 校正方程3
  // 2.6
  const double K[2] = {Eh[0] / denom,
                       Eh[1] / denom};
  // Ikh I-Kh
  // 2.9
  const double IKh[2][2] = {{1.0 - K[0]*h[0], -K[0]*h[1]},
                            {-K[1]*h[0], 1.0 - K[1]*h[1]}};
  const double e00 = E_[0][0];
  const double e01 = E_[0][1];
  // Update state.
  // 使用IKh更新误差矩阵
  // P(k) = (I - Kh)P(k - 1)
  // 校准方程5
  // 2.10
  E_[0][0] = e00 * IKh[0][0] + E_[1][0] * IKh[0][1];
  E_[0][1] = e01 * IKh[0][0] + E_[1][1] * IKh[0][1];
  E_[1][0] = e00 * IKh[1][0] + E_[1][0] * IKh[1][1];
  E_[1][1] = e01 * IKh[1][0] + E_[1][1] * IKh[1][1];
  // The covariance matrix must be positive semi-definite.
  bool positive_semi_definite = E_[0][0] + E_[1][1] >= 0 &&
      E_[0][0] * E_[1][1] - E_[0][1] * E_[1][0] >= 0 && E_[0][0] >= 0;
  assert(positive_semi_definite);
  if (!positive_semi_definite) {
    LOG(LS_ERROR) << "The over-use estimator's covariance matrix is no longer "
                     "semi-definite.";
  }
  // 2.8
  slope_ = slope_ + K[0] * residual;
  prev_offset_ = offset_;
  offset_ = offset_ + K[1] * residual;
}

// 这个函数主要提供下面函数需要用到的ts_delta，这里不是直接使用
// 本次的ts_delta，而是根据历史时间窗口中最小时间值作为噪声估计中的ts_delta
// 这个函数就是在一个固定的时间窗口中按时间顺序存放每一个ts_delta
// 当数量超过时就从最早的时间开始pop
// 然后遍历整个时间窗口选择最小的时间差值。
double OveruseEstimator::UpdateMinFramePeriod(double ts_delta) {
  double min_frame_period = ts_delta;
  if (ts_delta_hist_.size() >= kMinFramePeriodHistoryLength) {
    ts_delta_hist_.pop_front();
  }
  std::list<double>::iterator it = ts_delta_hist_.begin();
  for (; it != ts_delta_hist_.end(); it++) {
    min_frame_period = std::min(*it, min_frame_period);
  }
  ts_delta_hist_.push_back(ts_delta);
  return min_frame_period;
}
void OveruseEstimator::UpdateNoiseEstimate(double residual,
                                           double ts_delta,
                                           bool stable_state) {
  // 仅在Normal状态下更新噪声值。
  if (!stable_state) {
    return;
  }
  // Faster filter during startup to faster adapt to the jitter level
  // of the network. |alpha| is tuned for 30 frames per second, but is scaled
  // according to |ts_delta|.
  double alpha = 0.01;
  if (num_of_deltas_ > 10*30) {
    alpha = 0.002;
  }
  // Only update the noise estimate if we're not over-using. |beta| is a
  // function of alpha and the time delta since the previous update.
  // 时间差越大，残差的比重越小
  // 由于上面函数控制一个时间窗口，因此一个时间窗口内，其权重基本固定。
  const double beta = pow(1 - alpha, ts_delta * 30.0 / 1000.0);
  // 更新均值
  avg_noise_ = beta * avg_noise_
              + (1 - beta) * residual;
  // 利用方差更新噪声值。
  var_noise_ = beta * var_noise_
              + (1 - beta) * (avg_noise_ - residual) * (avg_noise_ - residual);
  if (var_noise_ < 1) {
    var_noise_ = 1;
  }
}

bool InterArrival::ComputeDeltas(uint32_t timestamp,
                                 int64_t arrival_time_ms,
                                 int64_t system_time_ms,
                                 size_t packet_size,
                                 uint32_t* timestamp_delta,
                                 int64_t* arrival_time_delta_ms,
                                 int* packet_size_delta) {
  assert(timestamp_delta != NULL);
  assert(arrival_time_delta_ms != NULL);
  assert(packet_size_delta != NULL);
  bool calculated_deltas = false;
  if (current_timestamp_group_.IsFirstPacket()) {
    // We don't have enough data to update the filter, so we store it until we
    // have two frames of data to process.
	// 尚未完全初始化
    current_timestamp_group_.timestamp = timestamp;
    current_timestamp_group_.first_timestamp = timestamp;
  } else if (!PacketInOrder(timestamp)) {
    return false;
  } else if (NewTimestampGroup(arrival_time_ms, timestamp)) {
    // First packet of a later frame, the previous frame sample is ready.
	// 需要新开一个group，此时计算prev_group和current_group的差值。
    if (prev_timestamp_group_.complete_time_ms >= 0) {
      // 发送时间的差值，即公式中的T(i) - T(i - 1)
      *timestamp_delta = current_timestamp_group_.timestamp -
                         prev_timestamp_group_.timestamp;
	  // 接收时间的差值，即公式中的t(i) - t(i - 1)
      *arrival_time_delta_ms = current_timestamp_group_.complete_time_ms -
                               prev_timestamp_group_.complete_time_ms;
      // Check system time differences to see if we have an unproportional jump
      // in arrival time. In that case reset the inter-arrival computations.
	  // 防止一些时间戳异常处理。
      int64_t system_time_delta_ms =
          current_timestamp_group_.last_system_time_ms -
          prev_timestamp_group_.last_system_time_ms;
      if (*arrival_time_delta_ms - system_time_delta_ms >=
          kArrivalTimeOffsetThresholdMs) {
        LOG(LS_WARNING) << "The arrival time clock offset has changed (diff = "
                        << *arrival_time_delta_ms - system_time_delta_ms
                        << " ms), resetting.";
        Reset();
        return false;
      }
	  // 乱序包的异常处理
      if (*arrival_time_delta_ms < 0) {
        // The group of packets has been reordered since receiving its local
        // arrival timestamp.
        ++num_consecutive_reordered_packets_;
		// 连续乱序包的异常处理
        if (num_consecutive_reordered_packets_ >= kReorderedResetThreshold) {
          LOG(LS_WARNING) << "Packets are being reordered on the path from the "
                             "socket to the bandwidth estimator. Ignoring this "
                             "packet for bandwidth estimation, resetting.";
          Reset();
        }
        return false;
      } else {
        num_consecutive_reordered_packets_ = 0;
      }
      assert(*arrival_time_delta_ms >= 0);
      *packet_size_delta = static_cast<int>(current_timestamp_group_.size) -
          static_cast<int>(prev_timestamp_group_.size);
      calculated_deltas = true;
    }
	// 更新整组group
    prev_timestamp_group_ = current_timestamp_group_;
    // The new timestamp is now the current frame.
    current_timestamp_group_.first_timestamp = timestamp;
    current_timestamp_group_.timestamp = timestamp;
    current_timestamp_group_.size = 0;
  } else {
	// 还在之前的时间范围内，此时将rtp timestanp更新，更新为一个新值。
    current_timestamp_group_.timestamp = LatestTimestamp(
        current_timestamp_group_.timestamp, timestamp);
  }
  // Accumulate the frame size.
  // 更新group中的数据。
  current_timestamp_group_.size += packet_size;
  current_timestamp_group_.complete_time_ms = arrival_time_ms;
  current_timestamp_group_.last_system_time_ms = system_time_ms;
  return calculated_deltas;
}
// Assumes that |timestamp| is not reordered compared to
// |current_timestamp_group_|.
bool InterArrival::NewTimestampGroup(int64_t arrival_time_ms,
                                     uint32_t timestamp) const {
  if (current_timestamp_group_.IsFirstPacket()) {
    return false;
  } else if (BelongsToBurst(arrival_time_ms, timestamp)) {
    return false;
  } else {
    uint32_t timestamp_diff = timestamp -
        current_timestamp_group_.first_timestamp;
    // rtp时间差大于一个Tick，即 90 * 5 个rtp时间采样点。
    return timestamp_diff > kTimestampGroupLengthTicks;
  }
}
// 允许group超出定死的group时间范围。
// 当这个函数返回false，会认为不是一个新的group。
bool InterArrival::BelongsToBurst(int64_t arrival_time_ms,
                                  uint32_t timestamp) const {
  if (!burst_grouping_) {
    return false;
  }
  assert(current_timestamp_group_.complete_time_ms >= 0);
  int64_t arrival_time_delta_ms = arrival_time_ms -
      current_timestamp_group_.complete_time_ms;
  uint32_t timestamp_diff = timestamp - current_timestamp_group_.timestamp;
  // 将rtp的时间差值转换为ms，乘上采样频率 1 / 90.
  int64_t ts_delta_ms = timestamp_to_ms_coeff_ * timestamp_diff + 0.5;
  if (ts_delta_ms == 0)
    return true;
  int propagation_delta_ms = arrival_time_delta_ms - ts_delta_ms;
  // 传播时间差，即当前包的RTT小于上一个包的RTT，且到达时间差小于爆发的阈值
  return propagation_delta_ms < 0 &&
      arrival_time_delta_ms <= kBurstDeltaThresholdMs;
}

class RateStatistics {
  // Counters are kept in buckets (circular buffer), with one bucket
  // per millisecond.
  // 每毫秒一个记录值。
  struct Bucket {
    size_t sum;      // Sum of all samples in this bucket.
    size_t samples;  // Number of samples in this bucket.
  };
  std::unique_ptr<Bucket[]> buckets_;
  // 统计总值，一个为总的传输字节数，一个为这个单位时间内，总的采样点数。
  // Total count recorded in buckets.
  size_t accumulated_count_;
  // The total number of samples in the buckets.
  size_t num_samples_;
  // 某个采样时间内的时间起点。包括时间值和索引值。
  // Oldest time recorded in buckets.
  int64_t oldest_time_;
  // Bucket index of oldest counter recorded in buckets.
  uint32_t oldest_index_;
  // 类的参数值
  // To convert counts/ms to desired units
  const float scale_;
  // The window sizes, in ms, over which the rate is calculated.
  // 最大的时间窗口，单位为毫秒，每一毫秒都有一个独立的Bucket，形成一个桶，桶的索引以时间计算。
  const int64_t max_window_size_ms_;
  int64_t current_window_size_ms_;
};

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;
  // now_ms在桶中的位置由基准时间(oldest_time)和自身时间的毫秒差作为索引。
  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_;
}
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>();
  }
  // 码率的因子，最后的值为（总大小 * scale_ / 总的有效时间）
  float scale = scale_ / active_window_size;
  return rtc::Optional<uint32_t>(
      static_cast<uint32_t>(accumulated_count_ * scale + 0.5f));
}
void RateStatistics::EraseOld(int64_t now_ms) {
  if (!IsInitialized())
    return;
  // New oldest time that is included in data set.
  // 根据窗口大小更新当前时间窗口，更新为[now_ms - 窗口， now_ms]
  int64_t new_oldest_time = now_ms - current_window_size_ms_ + 1;
  // New oldest time is older than the current one, no need to cull data.
  if (new_oldest_time <= oldest_time_)
    return;
  // Loop over buckets and remove too old data points.
  // 从当前时间窗口下限开始逐毫秒遍历
  while (num_samples_ > 0 && oldest_time_ < new_oldest_time) {
    const Bucket& oldest_bucket = buckets_[oldest_index_];
    RTC_DCHECK_GE(accumulated_count_, oldest_bucket.sum);
    RTC_DCHECK_GE(num_samples_, oldest_bucket.samples);
	// 从统计数据中将超时的Bucket中的数据扣除，并清空Bucket。
    accumulated_count_ -= oldest_bucket.sum;
    num_samples_ -= oldest_bucket.samples;
    buckets_[oldest_index_] = Bucket();
	// 环形
    if (++oldest_index_ >= max_window_size_ms_)
      oldest_index_ = 0;
    ++oldest_time_;
  }
  oldest_time_ = new_oldest_time;
}

/* 这个函数根据对应的report block生成了一个新的RTCPReportBlockInformation结构体，
 * 并计算出对应的RTT，多report block在调用点处执行循环。  */
void RTCPReceiver::HandleReportBlock(
    const RTCPUtility::RTCPPacket& rtcpPacket,
    RTCPPacketInformation& rtcpPacketInformation,
    uint32_t remoteSSRC)
    EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
  // This will be called once per report block in the RTCP packet.
  // We filter out all report blocks that are not for us.
  // Each packet has max 31 RR blocks.
  //
  // We can calc RTT if we send a send report and get a report block back.
  // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to
  // which the information in this reception report block pertains.
  // Filter out all report blocks that are not for us.
  if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) ==
      registered_ssrcs_.end()) {
    // This block is not for us ignore it.
    return;
  }
  RTCPReportBlockInformation* reportBlock =
      CreateOrGetReportBlockInformation(remoteSSRC,
                                        rtcpPacket.ReportBlockItem.SSRC);
  if (reportBlock == NULL) {
    LOG(LS_WARNING) << "Failed to CreateReportBlockInformation("
                    << remoteSSRC << ")";
    return;
  }
  // 用于RTCP超时的计算。
  _lastReceivedRrMs = _clock->TimeInMilliseconds();
  // 其他字段的拷贝。
  const RTCPPacketReportBlockItem& rb = rtcpPacket.ReportBlockItem;
  reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC;
  reportBlock->remoteReceiveBlock.sourceSSRC = rb.SSRC;
  reportBlock->remoteReceiveBlock.fractionLost = rb.FractionLost;
  reportBlock->remoteReceiveBlock.cumulativeLost =
      rb.CumulativeNumOfPacketsLost;
  if (rb.ExtendedHighestSequenceNumber >
      reportBlock->remoteReceiveBlock.extendedHighSeqNum) {
    // We have successfully delivered new RTP packets to the remote side after
    // the last RR was sent from the remote side.
    _lastIncreasedSequenceNumberMs = _lastReceivedRrMs;
  }
  reportBlock->remoteReceiveBlock.extendedHighSeqNum =
      rb.ExtendedHighestSequenceNumber;
  reportBlock->remoteReceiveBlock.jitter = rb.Jitter;
  reportBlock->remoteReceiveBlock.delaySinceLastSR = rb.DelayLastSR;
  reportBlock->remoteReceiveBlock.lastSR = rb.LastSR;
  if (rtcpPacket.ReportBlockItem.Jitter > reportBlock->remoteMaxJitter) {
    reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter;
  }
  int64_t rtt = 0;
  uint32_t send_time = rtcpPacket.ReportBlockItem.LastSR;
  // RFC3550, section 6.4.1, LSR field discription states:
  // If no SR has been received yet, the field is set to zero.
  // Receiver rtp_rtcp module is not expected to calculate rtt using
  // Sender Reports even if it accidentally can.
  if (!receiver_only_ && send_time != 0) {
	// 当RR在SR之前发送，send_time为0.
	// delay计算:
	// Send SR                                                       Receive RR
	//  |                          delay in RR                           |
 	//  |                        |<----------->|                         |
	//  |<---------------------->|             |<----------------------->|
	//
	// RTT = total_time - delay_in_RR
	//     = receiver_rr_time - send_sr_time - delay_in_RR
	// 即使中间几个SR丢包，但是如果RTT本身是平滑的，那么RTT不会受到这几个丢包的影响
	// 因为SR->RR之间的delay可以精确计算。
    uint32_t delay = rtcpPacket.ReportBlockItem.DelayLastSR;
    // Local NTP time.
    uint32_t receive_time = CompactNtp(NtpTime(*_clock));
    // RTT in 1/(2^16) seconds.
    uint32_t rtt_ntp = receive_time - delay - send_time;
    // Convert to 1/1000 seconds (milliseconds).
    rtt = CompactNtpRttToMs(rtt_ntp);
    if (rtt > reportBlock->maxRTT) {
      // Store max RTT.
      reportBlock->maxRTT = rtt;
    }
    if (reportBlock->minRTT == 0) {
      // First RTT.
      reportBlock->minRTT = rtt;
    } else if (rtt < reportBlock->minRTT) {
      // Store min RTT.
      reportBlock->minRTT = rtt;
    }
    // Store last RTT.
    reportBlock->RTT = rtt;
    // store average RTT
	// RTT的平滑计算。
	// 如果这个块是在CreateOrGetReportBlockInformation新生成的，
	// 则权重会从0开始随着受到的report逐渐递增。
	// srtt(i) = i/(i+1)*srtt(i-1) + 1/(i+1)*rtt + 0.5
    if (reportBlock->numAverageCalcs != 0) {
      float ac = static_cast<float>(reportBlock->numAverageCalcs);
      float newAverage =
          ((ac / (ac + 1)) * reportBlock->avgRTT) + ((1 / (ac + 1)) * rtt);
      reportBlock->avgRTT = static_cast<int64_t>(newAverage + 0.5f);
    } else {
      // First RTT.
      reportBlock->avgRTT = rtt;
    }
    reportBlock->numAverageCalcs++;
  }
  TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC,
                    rtt);
  // 添加回rtcpPacketInformation，在ModuleRtpRtcpImpl中会使用这个进行事件回调。
  rtcpPacketInformation.AddReportInfo(*reportBlock);
}

// Updates history of min bitrates.
// After this method returns min_bitrate_history_.front().second contains the
// min bitrate used during last kBweIncreaseIntervalMs.
// 主要结合这个函数解释下变量min_bitrate_history_
// 这个变量的两个维度，front记录的是离当前最远的时间，
// 每个速率都是按照时间先后顺序逐渐push到尾部。
// 因此更新的时候，需要先将超时的元素从列表头剔除。
// 后一个维度是最小速率值，
// 在相同的时间区间内，保留最小的速率值。
// |-------Interval 1---------|----------Interval 2------|
// |                          |                          |
// |--t1 < t2 < t3 < t4 < t5--|--t1 < t2 < t3 < t4 < t5--|
// 这样的操作较为简单，不用在每次插入元素时去判断对应的时间区域，再找到对应时间区间的最小值，用部分冗余的内存换取操作的快捷。
void SendSideBandwidthEstimation::UpdateMinHistory(int64_t now_ms) {
  // Remove old data points from history.
  // Since history precision is in ms, add one so it is able to increase
  // bitrate if it is off by as little as 0.5ms.
  while (!min_bitrate_history_.empty() &&
         now_ms - min_bitrate_history_.front().first + 1 >
             kBweIncreaseIntervalMs) {
    min_bitrate_history_.pop_front();
  }
  // Typical minimum sliding-window algorithm: Pop values higher than current
  // bitrate before pushing it.
  while (!min_bitrate_history_.empty() &&
         bitrate_ <= min_bitrate_history_.back().second) {
    min_bitrate_history_.pop_back();
  }
  min_bitrate_history_.push_back(std::make_pair(now_ms, bitrate_));
}

void SendSideBandwidthEstimation::UpdateEstimate(int64_t now_ms) {
  // We trust the REMB and/or delay-based estimate during the first 2 seconds if
  // we haven't had any packet loss reported, to allow startup bitrate probing.
  if (last_fraction_loss_ == 0 && IsInStartPhase(now_ms)) {
    uint32_t prev_bitrate = bitrate_;
	// bwe_incoming_是remb更新的值，如果当前无丢包且在启动阶段，直接使用remb的值。
    if (bwe_incoming_ > bitrate_)
      bitrate_ = CapBitrateToThresholds(now_ms, bwe_incoming_);
      ...
    }
  }
  UpdateMinHistory(now_ms);
  // Only start updating bitrate when receiving receiver blocks.
  // TODO(pbos): Handle the case when no receiver report is received for a very
  // long time.
  if (time_last_receiver_block_ms_ != -1) {
    if (last_fraction_loss_ <= 5) {
      // Loss < 2%: Increase rate by 8% of the min bitrate in the last
      // kBweIncreaseIntervalMs.
      // Note that by remembering the bitrate over the last second one can
      // rampup up one second faster than if only allowed to start ramping
      // at 8% per second rate now. E.g.:
      //   If sending a constant 100kbps it can rampup immediatly to 108kbps
      //   whenever a receiver report is received with lower packet loss.
      //   If instead one would do: bitrate_ *= 1.08^(delta time), it would
      //   take over one second since the lower packet loss to achieve 108kbps.
        
        //TODO:tjl
	  // 这里与公式有一定不同：
	  // 1. 系数不同，且附带一定的修正值(向上取整加1kbps)
	  // 2. 取的是上一个时间间隔之内最小值，比较平滑。
      bitrate_ = static_cast<uint32_t>(
          min_bitrate_history_.front().second * 1.08 + 0.5);
      // Add 1 kbps extra, just to make sure that we do not get stuck
      // (gives a little extra increase at low rates, negligible at higher
      // rates).
      bitrate_ += 1000;
      event_log_->LogBwePacketLossEvent(
          bitrate_, last_fraction_loss_,
          expected_packets_since_last_loss_update_);
    } else if (last_fraction_loss_ <= 26) {
      // Loss between 2% - 10%: Do nothing.
    } else {
      // Loss > 10%: Limit the rate decreases to once a kBweDecreaseIntervalMs +
      // rtt.
      if (!has_decreased_since_last_fraction_loss_ &&
          (now_ms - time_last_decrease_ms_) >=
              (kBweDecreaseIntervalMs + last_round_trip_time_ms_)) {
        time_last_decrease_ms_ = now_ms;
        // Reduce rate:
        //   newRate = rate * (1 - 0.5*lossRate);
        //   where packetLoss = 256*lossRate;
          
          //TODO:tjl
		// 当从未开始降低窗口值，且距离上一次衰减的时间差大于衰减周期加上rtt。
		// 其实当前貌似只有这个case下会对这两个变量赋值。
		// 这里的last_fraction_loss_是一次统计间隔(一定包数)之间的总丢包率。
		// 丢包率的单位是1/256，因此这里是(1 - 丢包率/2) * 当前速率
		// 与公式相同。
        bitrate_ = static_cast<uint32_t>(
            (bitrate_ * static_cast<double>(512 - last_fraction_loss_)) /
            512.0);
        has_decreased_since_last_fraction_loss_ = true;
      }
      event_log_->LogBwePacketLossEvent(
          bitrate_, last_fraction_loss_,
          expected_packets_since_last_loss_update_);
    }
  }
  // 在有效范围内修正。
  bitrate_ = CapBitrateToThresholds(now_ms, bitrate_);
}

/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
// 这个函数中如果可以恢复，则会直接进入CA_OPEN。
// 不进入CA_OPEN则会直接返回tcp_ack中进行重传(或者是发送新分片)。
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack,
			     int *rexmit)
{
	struct tcp_sock *tp = tcp_sk(sk);
	// 完全恢复
	bool recovered = !before(tp->snd_una, tp->high_seq);
	// 最大的未确认包已经发生改变，可能是之前丢包已经恢复，尝试撤销丢包状态。
	// 当frto关闭时，这是唯二可以退出LOSS状态的条件。
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;
	// frto在enter_loss时候置位，根据超时时的设置决定是否可能是一个虚假的RTO。
	if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
		/* Step 3.b. A timeout is spurious if not all data are
		 * lost, i.e., never-retransmitted data are (s)acked.
		 */
		// #define FLAG_ORIG_SACK_ACKED	0x200 /* Never retransmitted data are (s)acked	*/
		// 包没有丢，因为还没重传就收到了ACK，只是延迟了，这是虚假RTO，撤销丢包状态。
		// 注: 这里的frto_undo传参为true，必定恢复。
		// 对应RTO论文图中的延迟包的acks。
		if ((flag & FLAG_ORIG_SACK_ACKED) &&
		    tcp_try_undo_loss(sk, true))
			return;
		if (after(tp->snd_nxt, tp->high_seq)) {
			// 如果是刚进入LOSS状态，会先尝试重传，这时候snd_nxt总是等于high_seq的，
			// 这个分支主要对应3.2.b之后发送了两个新分片。
			// 虽然发送了新分片，没有发重传，但是这时候收到的ack并没有更新una
			// 说明这个rtt中，之前una的包仍旧没有达到，因此这里认为他是真的超时
			// 关闭frto。对应3.3.a
			if (flag & FLAG_DATA_SACKED || is_dupack)
				tp->frto = 0; /* Step 3.a. loss was real */
		} else if (flag & FLAG_SND_UNA_ADVANCED && !recovered) {
			// 这里进入的条件为
			// 1. snd_nxt == high_seq，还没发送过新分片
			// 2. una更新过，且没有完全恢复
			// 执行3.2.b，发送新分片。
			// 对应论文图中收到了一个更新过snd_una的ack。
			tp->high_seq = tp->snd_nxt;
			/* Step 2.b. Try send new data (but deferred until cwnd
			 * is updated in tcp_ack()). Otherwise fall back to
			 * the conventional recovery.
			 */
			// 3.2.b中判断当前是否可以发送新分片。
			if (tcp_send_head(sk) &&
			    after(tcp_wnd_end(tp), tp->snd_nxt)) {
				*rexmit = REXMIT_NEW;
				return;
			}
			tp->frto = 0;
		}
	}
	// 已经完全恢复，则撤销对应的恢复操作，并进入TCP_CA_OPEN状态。后续将进入恢复状态。
	// 这里主要处理了其他几个不在FRTO可处理的场景，如3.2.a和3.3.a
	// 唯一进入这里但frto还可能生效的场景为:
	// 发送新分片后，但是收到了一个不是新的sack，且不是一个dup sack。
	// 在这种情况下的处理应该和上一个旧的sack相同。
	// 个人理解应该是3.3中被忽略的case。
	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
		tcp_try_undo_recovery(sk);
		return;
	}
	if (tcp_is_reno(tp)) {
		/* A Reno DUPACK means new data in F-RTO step 2.b above are
		 * delivered. Lower inflight to clock out (re)tranmissions.
		 */
		if (after(tp->snd_nxt, tp->high_seq) && is_dupack)
			tcp_add_reno_sack(sk);
		else if (flag & FLAG_SND_UNA_ADVANCED)
			tcp_reset_reno_sack(tp);
	}
	*rexmit = REXMIT_LOST;
}