Change VideoReceiveStream::Stats total_bitrate_bps to include all received packets.

webrtc/video/receive_statistics_proxy.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 55 matching lines @@
                           kHighVarianceThreshold,
                           kBadFraction,
                           kNumMeasurementsVariance),
       num_bad_states_(0),
       num_certain_states_(0),
       // 1000ms window, scale 1000 for ms to s.
       decode_fps_estimator_(1000, 1000),
       renders_fps_estimator_(1000, 1000),
       render_fps_tracker_(100, 10u),
       render_pixel_tracker_(100, 10u),
+      total_byte_tracker_(100, 10u),  // bucket_interval_ms, bucket_count
       freq_offset_counter_(clock, nullptr, kFreqOffsetProcessIntervalMs),
       first_report_block_time_ms_(-1),
-      avg_rtt_ms_(0),
-      frame_window_accumulated_bytes_(0) {
+      avg_rtt_ms_(0) {
   stats_.ssrc = config_.rtp.remote_ssrc;
   // TODO(brandtr): Replace |rtx_stats_| with a single instance of
   // StreamDataCounters.
   if (config_.rtp.rtx_ssrc) {
     rtx_stats_[config_.rtp.rtx_ssrc] = StreamDataCounters();
   }
 }
 
 ReceiveStatisticsProxy::~ReceiveStatisticsProxy() {
   UpdateHistograms();
@@ skipping 215 matching lines @@
   qp_sample_.Reset();
 
   if (fps_threshold_.IsHigh() || variance_threshold_.IsHigh() ||
       qp_threshold_.IsHigh()) {
     if (any_bad)
       ++num_bad_states_;
     ++num_certain_states_;
   }
 }
 
-void ReceiveStatisticsProxy::UpdateFrameAndBitrate(int64_t now_ms) const {
+void ReceiveStatisticsProxy::UpdateFramerate(int64_t now_ms) const {
   int64_t old_frames_ms = now_ms - kRateStatisticsWindowSizeMs;
   while (!frame_window_.empty() &&
          frame_window_.begin()->first < old_frames_ms) {
-    frame_window_accumulated_bytes_ -= frame_window_.begin()->second;
     frame_window_.erase(frame_window_.begin());
   }
 
   size_t framerate =
       (frame_window_.size() * 1000 + 500) / kRateStatisticsWindowSizeMs;
-  size_t bitrate_bps =
-      frame_window_accumulated_bytes_ * 8000 / kRateStatisticsWindowSizeMs;
   stats_.network_frame_rate = static_cast<int>(framerate);
-  stats_.total_bitrate_bps = static_cast<int>(bitrate_bps);
 }
 
 VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
   rtc::CritScope lock(&crit_);
-  UpdateFrameAndBitrate(clock_->TimeInMilliseconds());
+  UpdateFramerate(clock_->TimeInMilliseconds());
+  stats_.total_bitrate_bps =
+      static_cast<int>(total_byte_tracker_.ComputeRate() * 8);
   return stats_;
 }
 
 void ReceiveStatisticsProxy::OnIncomingPayloadType(int payload_type) {
   rtc::CritScope lock(&crit_);
   stats_.current_payload_type = payload_type;
 }
 
 void ReceiveStatisticsProxy::OnDecoderImplementationName(
     const char* implementation_name) {
@@ skipping 61 matching lines @@
   // TODO(pbos): Handle both local and remote ssrcs here and RTC_DCHECK that we
   // receive stats from one of them.
   if (stats_.ssrc != ssrc)
     return;
   stats_.c_name = cname;
 }
 
 void ReceiveStatisticsProxy::DataCountersUpdated(
     const webrtc::StreamDataCounters& counters,
     uint32_t ssrc) {
+  size_t last_total_bytes = 0;
+  size_t total_bytes = 0;
   rtc::CritScope lock(&crit_);
   if (ssrc == stats_.ssrc) {
+    last_total_bytes = stats_.rtp_stats.transmitted.TotalBytes();
+    total_bytes = counters.transmitted.TotalBytes();
     stats_.rtp_stats = counters;
   } else {
     auto it = rtx_stats_.find(ssrc);
     if (it != rtx_stats_.end()) {
+      last_total_bytes = it->second.transmitted.TotalBytes();
+      total_bytes = counters.transmitted.TotalBytes();
       it->second = counters;
     } else {
       RTC_NOTREACHED() << "Unexpected stream ssrc: " << ssrc;
     }
   }
+  if (total_bytes > last_total_bytes)

[stefan-webrtc, 2017/03/28 07:13:02]

What should we do if this is not true? Seems like we should reset something?

[åsapersson, 2017/03/28 07:59:23]

Not sure if it can happen but if the counters are reset I think it is ok to keep
the already counted bytes during the last second (interval used by
ComputeRate()).

[stefan-webrtc, 2017/03/28 09:18:53]

Ok.

+    total_byte_tracker_.AddSamples(total_bytes - last_total_bytes);
 }
 
 void ReceiveStatisticsProxy::OnDecodedFrame(rtc::Optional<uint8_t> qp) {
   uint64_t now = clock_->TimeInMilliseconds();
 
   rtc::CritScope lock(&crit_);
   ++stats_.frames_decoded;
   if (qp) {
     if (!stats_.qp_sum) {
       if (stats_.frames_decoded != 1) {
@@ skipping 59 matching lines @@
 
 void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe,
                                              size_t size_bytes) {
   rtc::CritScope lock(&crit_);
   if (is_keyframe)
     ++stats_.frame_counts.key_frames;
   else
     ++stats_.frame_counts.delta_frames;
 
   int64_t now_ms = clock_->TimeInMilliseconds();
-  frame_window_accumulated_bytes_ += size_bytes;
   frame_window_.insert(std::make_pair(now_ms, size_bytes));
-  UpdateFrameAndBitrate(now_ms);
+  UpdateFramerate(now_ms);
 }
 
 void ReceiveStatisticsProxy::OnFrameCountsUpdated(
     const FrameCounts& frame_counts) {
   rtc::CritScope lock(&crit_);
   stats_.frame_counts = frame_counts;
 }
 
 void ReceiveStatisticsProxy::OnDiscardedPacketsUpdated(int discarded_packets) {
   rtc::CritScope lock(&crit_);
@@ skipping 30 matching lines @@
   sum = 0;
 }
 
 void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms,
                                          int64_t max_rtt_ms) {
   rtc::CritScope lock(&crit_);
   avg_rtt_ms_ = avg_rtt_ms;
 }
 
 }  // namespace webrtc