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 353 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 empty, so it will be always
+  // overwritten in |OnTimingFrameInfoUpdated|, thus allowing to store new
+  // value instead of reported one.
+  timing_frame_info_.reset();

[sprang_webrtc, 2017/06/28 15:31:41]

I think this is problematic, since the GetStats calls can come from several
places, not all of them are from the "desired" call site.
Could we break out the timing frame polling to a separate method for appending
that data? Then we have a way to explicitly reset it and don't need a mutable
member. We'd need on in VideoReceiveStream as well then

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

I don't understand what do you mean. In the end, it still will be returned via
GetStats, won't it? And there are no parameters to GetStats to understand if
it's called from a 'desired' state.

One solution would be to not reset observed timing frame info at all and return
the 'longest' timing frame for whole call so far. Or we could just return the
latest one available. Some outliers may be missed this way.

[sprang_webrtc, 2017/06/30 21:38:20]

I was thinking of direct calls to ReceiveStatisticsProxy from within the native
stack. I've seen usages like that where rather than implement a new rate tracker
or add another callback for bitrate/framrate etc we just call the stats proxies.


It'd be silly if we lost data because we had calls from vie_encode or jitter
estimator or whatnot.

   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.
+  if (!timing_frame_info_ || info.IsLongerThan(*timing_frame_info_)) {
+    timing_frame_info_.emplace(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