Report timing frames info in GetStats.

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 62 matching lines @@
       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
       e2e_delay_max_ms_video_(-1),
       e2e_delay_max_ms_screenshare_(-1),
       freq_offset_counter_(clock, nullptr, kFreqOffsetProcessIntervalMs),
       first_report_block_time_ms_(-1),
       avg_rtt_ms_(0),
-      last_content_type_(VideoContentType::UNSPECIFIED) {
+      last_content_type_(VideoContentType::UNSPECIFIED),
+      timing_frame_info_() {
   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 270 matching lines @@
 VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
   rtc::CritScope lock(&crit_);
   // Get current frame rates here, as only updating them on new frames prevents
   // us from ever correctly displaying frame rate of 0.
   int64_t now_ms = clock_->TimeInMilliseconds();
   UpdateFramerate(now_ms);
   stats_.render_frame_rate = renders_fps_estimator_.Rate(now_ms).value_or(0);
   stats_.decode_frame_rate = decode_fps_estimator_.Rate(now_ms).value_or(0);
   stats_.total_bitrate_bps =
       static_cast<int>(total_byte_tracker_.ComputeRate() * 8);
+  stats_.timing_frame_info = timing_frame_info_;
+  // Reset reported value to default, because default value will be always
+  // overwritten in |OnTimingFrameInfoUpdated|, thus allowing to store new
+  // value instead of reported one.
+  timing_frame_info_ = TimingFrameInfo();
   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 41 matching lines @@
                        "target_delay_ms", target_delay_ms,
                        "ssrc", stats_.ssrc);
   TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.JitterBufferDelayInMs",
                        "jitter_buffer_ms", jitter_buffer_ms,
                        "ssrc", stats_.ssrc);
   TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.RenderDelayInMs",
                        "render_delay_ms", render_delay_ms,
                        "ssrc", stats_.ssrc);
 }
 
+void ReceiveStatisticsProxy::OnTimingFrameInfoUpdated(
+    const TimingFrameInfo& info) {
+  rtc::CritScope lock(&crit_);
+  // Only the frame which was processed the longest since the last
+  // GetStats() call is reported. Therefore, only single 'longest' frame is
+  // stored.

[hbos, 2017/06/27 14:08:31]

Could we get the latest instead of the longest? Or something which does not rely
on "previous call to GetStats"?

[ilnik, 2017/06/27 15:23:56]

Can be simply latest, but this way we may loose important bit of information.
Outliers are more interesting for analysis. For each call we can report only a
single frame information. So we choose most interesting among all frames since
last call instead of latest.

[Taylor Brandstetter, 2017/06/28 07:27:46]

If I understand correctly, the whole motivation here is to find the outliers,
since they're the frames that end up increasing latency or causing frame drops.
And for those outliers, find out what parts of the pipeline are the bottlenecks
so they can be improved. With that in mind, this makes sense. It's more of a
debugging tool than a typical "stat", which justifies it not adhering to normal
GetStats conventions. If this interpretation is correct, it would be helpful if
the CL description and/or comments made this more clear, in case someone
encounters this code later without context.

[ilnik, 2017/06/29 08:39:56]

Done.

+  if (info.IsLongerThan(timing_frame_info_)) {
+    timing_frame_info_ = info;
+  }
+}
+
 void ReceiveStatisticsProxy::RtcpPacketTypesCounterUpdated(
     uint32_t ssrc,
     const RtcpPacketTypeCounter& packet_counter) {
   rtc::CritScope lock(&crit_);
   if (stats_.ssrc != ssrc)
     return;
   stats_.rtcp_packet_type_counts = packet_counter;
 }
 
 void ReceiveStatisticsProxy::StatisticsUpdated(
@@ skipping 185 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