Add resolution and fps stats to histograms.

webrtc/video/send_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.
  */
 
 #include "webrtc/video/send_statistics_proxy.h"
 
+#include <algorithm>
 #include <map>
 
 #include "webrtc/base/checks.h"
 
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 
 namespace webrtc {
 
 const int SendStatisticsProxy::kStatsTimeoutMs = 5000;
 
 SendStatisticsProxy::SendStatisticsProxy(Clock* clock,
                                          const VideoSendStream::Config& config)
-    : clock_(clock), config_(config), last_sent_frame_timestamp_(0) {
+    : clock_(clock),
+      config_(config),
+      last_sent_frame_timestamp_(0),
+      max_sent_width_per_timestamp_(0),
+      max_sent_height_per_timestamp_(0) {
 }
 
 SendStatisticsProxy::~SendStatisticsProxy() {
   UpdateHistograms();
 }
 
 void SendStatisticsProxy::UpdateHistograms() {
   int input_fps =
       static_cast<int>(input_frame_rate_tracker_total_.units_second());
+  if (input_fps > 0)
+    RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.InputFramesPerSecond", input_fps);
   int sent_fps =
       static_cast<int>(sent_frame_rate_tracker_total_.units_second());
-
-  if (input_fps > 0)
-    RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.InputFramesPerSecond", input_fps);
   if (sent_fps > 0)
     RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.SentFramesPerSecond", sent_fps);
+
+  const int kMinRequiredSamples = 100;
+  int in_width = input_width_counter_.Avg(kMinRequiredSamples);
+  if (in_width != -1)

[pbos-webrtc, 2015/07/20 13:52:22]

Same here, treat in_{width,height} as one pair, and do one check.

Then treat sent_{...} as one pair and do one check. This makes it easier to
read. :)

[åsapersson, 2015/07/20 15:06:30]

Done.

+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InputWidthInPixels", in_width);
+  int in_height = input_height_counter_.Avg(kMinRequiredSamples);
+  if (in_height != -1)
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InputHeightInPixels", in_height);
+  int sent_width = sent_width_counter_.Avg(kMinRequiredSamples);
+  if (sent_width != -1)
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.SentWidthInPixels", sent_width);
+  int sent_height = sent_height_counter_.Avg(kMinRequiredSamples);
+  if (sent_height != -1)
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.SentHeightInPixels", sent_height);
 }
 
 void SendStatisticsProxy::OutgoingRate(const int video_channel,
                                        const unsigned int framerate,
                                        const unsigned int bitrate) {
   rtc::CritScope lock(&crit_);
   stats_.encode_frame_rate = framerate;
   stats_.media_bitrate_bps = bitrate;
 }
 
@@ skipping 78 matching lines @@
   uint32_t ssrc = config_.rtp.ssrcs[simulcast_idx];
 
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
 
   stats->width = encoded_image._encodedWidth;
   stats->height = encoded_image._encodedHeight;
   update_times_[ssrc].resolution_update_ms = clock_->TimeInMilliseconds();
-  if (encoded_image._timeStamp != last_sent_frame_timestamp_) {
-    last_sent_frame_timestamp_ = encoded_image._timeStamp;
+
+  if (last_sent_frame_timestamp_ > 0 &&

[pbos-webrtc, 2015/07/20 13:52:22]

Write a TODO() saying that this is incorrect if simulcast layers are encoded on
different threads and there's no guarantee (which afaik there isn't) that one
frame of all layers are encoded before the next start. Not sure if this happens
in practice, but it could make sense to keep a look out for >30fps stats
presence.

Frame 1 (320x180), Frame 1 (640x360), Frame 2 (320x180), Frame 1 (1280x720),
Frame 2 (640x480)...

In this case 720p of Frame 1 will look like a new frame, as will Frame 2 of VGA.

[åsapersson, 2015/07/20 15:06:30]

Done, added comment.

+      encoded_image._timeStamp != last_sent_frame_timestamp_) {
     sent_frame_rate_tracker_total_.Update(1);
+    sent_width_counter_.Add(max_sent_width_per_timestamp_);
+    sent_height_counter_.Add(max_sent_height_per_timestamp_);
+    max_sent_width_per_timestamp_ = 0;
+    max_sent_height_per_timestamp_ = 0;
   }
+  last_sent_frame_timestamp_ = encoded_image._timeStamp;
+  max_sent_width_per_timestamp_ = std::max(max_sent_width_per_timestamp_,
+      static_cast<int>(encoded_image._encodedWidth));
+  max_sent_height_per_timestamp_ = std::max(max_sent_height_per_timestamp_,
+      static_cast<int>(encoded_image._encodedHeight));
 }
 
-void SendStatisticsProxy::OnIncomingFrame() {
+void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
   rtc::CritScope lock(&crit_);
   input_frame_rate_tracker_.Update(1);
   input_frame_rate_tracker_total_.Update(1);
+  input_width_counter_.Add(width);
+  input_height_counter_.Add(height);
 }
 
 void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
     uint32_t ssrc,
     const RtcpPacketTypeCounter& packet_counter) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
 
@@ skipping 51 matching lines @@
                                                uint32_t ssrc) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
   stats->avg_delay_ms = avg_delay_ms;
   stats->max_delay_ms = max_delay_ms;
 }
 
 }  // namespace webrtc