Piggybacking simulcast id and ALR experiment id into video content type extension.

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.
  */
 
 #include "webrtc/video/receive_statistics_proxy.h"
 
 #include <algorithm>
 #include <cmath>
+#include <sstream>
 #include <utility>
 
+#include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 // Periodic time interval for processing samples for |freq_offset_counter_|.
@@ skipping 11 matching lines @@
 const int kHighFpsThreshold = 14;
 // For qp and fps variance:
 // Low means low enough to be good, high means high enough to be bad
 const int kLowQpThresholdVp8 = 60;
 const int kHighQpThresholdVp8 = 70;
 const int kLowVarianceThreshold = 1;
 const int kHighVarianceThreshold = 2;
 
 // How large window we use to calculate the framerate/bitrate.
 const int kRateStatisticsWindowSizeMs = 1000;
+
+std::string UmaPrefixForContentType(VideoContentType content_type) {
+  std::stringstream ss;
+  ss << "WebRTC.Video";
+  if (content_type.IsScreenshare()) {
+    ss << ".Screenshare";
+  }
+  return ss.str();
+}
+
+std::string UmaSpatialSuffixForContentType(VideoContentType content_type) {
+  std::stringstream ss;
+  int simulcast_id = content_type.GetSimulcastId();
+  if (simulcast_id > 0) {
+    ss << ".S" << simulcast_id - 1;
+  }
+  return ss.str();
+}
+
+std::string UmaExperimentSuffixConentType(VideoContentType content_type) {

[sprang_webrtc, 2017/08/25 13:56:29]

nit: UmaExperimentSuffixForContentType

[ilnik, 2017/08/25 14:14:27]

Done.

+  std::stringstream ss;
+  int experiment_id = content_type.GetExperimentId();
+  if (experiment_id > 0) {
+    ss << ".ExperimentGroup" << experiment_id - 1;
+  }
+  return ss.str();
+}
 }  // namespace
 
 ReceiveStatisticsProxy::ReceiveStatisticsProxy(
     const VideoReceiveStream::Config* config,
     Clock* clock)
     : clock_(clock),
       config_(*config),
       start_ms_(clock->TimeInMilliseconds()),
       last_sample_time_(clock->TimeInMilliseconds()),
       fps_threshold_(kLowFpsThreshold,
                      kHighFpsThreshold,
                      kBadFraction,
                      kNumMeasurements),
       qp_threshold_(kLowQpThresholdVp8,
                     kHighQpThresholdVp8,
                     kBadFraction,
                     kNumMeasurements),
       variance_threshold_(kLowVarianceThreshold,
                           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
-      e2e_delay_max_ms_video_(-1),
-      e2e_delay_max_ms_screenshare_(-1),
-      interframe_delay_max_ms_video_(-1),
-      interframe_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) {
   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();
 }
 
 void ReceiveStatisticsProxy::UpdateHistograms() {
-  RTC_HISTOGRAM_COUNTS_100000(
-      "WebRTC.Video.ReceiveStreamLifetimeInSeconds",
-      (clock_->TimeInMilliseconds() - start_ms_) / 1000);
+  const int kMinRequiredSamples = 200;
 
-  if (first_report_block_time_ms_ != -1 &&
-      ((clock_->TimeInMilliseconds() - first_report_block_time_ms_) / 1000) >=
-          metrics::kMinRunTimeInSeconds) {
-    int fraction_lost = report_block_stats_.FractionLostInPercent();
-    if (fraction_lost != -1) {
-      RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.ReceivedPacketsLostInPercent",
-                               fraction_lost);
-      LOG(LS_INFO) << "WebRTC.Video.ReceivedPacketsLostInPercent "
-                   << fraction_lost;
-    }
-  }
-
-  const int kMinRequiredSamples = 200;
   int samples = static_cast<int>(render_fps_tracker_.TotalSampleCount());
   if (samples >= kMinRequiredSamples) {
     RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.RenderFramesPerSecond",
                              round(render_fps_tracker_.ComputeTotalRate()));
     RTC_HISTOGRAM_COUNTS_100000(
         "WebRTC.Video.RenderSqrtPixelsPerSecond",
         round(render_pixel_tracker_.ComputeTotalRate()));
   }
+
+  // Slice on content type and simulcast id.
+  for (auto it : content_specific_stats_) {
+    auto content_type = it.first;
+    if (content_type.GetExperimentId() == 0 &&
+        content_type.GetSimulcastId() == 0) {
+      // Name of a metric sliced on simulcast is the same as sliced on
+      // experiment because no slice information is available in both cases.
+      // Don't report the metric here to not duplicate the metric.
+      continue;
+    }
+    auto stats = it.second;
+    std::string uma_prefix = UmaPrefixForContentType(content_type);
+    std::string uma_suffix = UmaSpatialSuffixForContentType(content_type);
+    // The same line of code can't report different histograms because of how
+    // macro is done. Additional index needed to be different for all different
+    // names. Since experiment can't change during call, we could report 4*2
+    // different content types (4 simulcast_ids x 2 content types).
+    // Conveniently all of these are stored in 3 lower bits in VideoContentType.
+    int idx = content_type.content_type & 0x07;
+    int e2e_delay_ms = stats.e2e_delay_counter.Avg(kMinRequiredSamples);
+    if (e2e_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".EndToEndDelayInMs" + uma_suffix, e2e_delay_ms);
+      LOG(LS_INFO) << uma_prefix << ".EndToEndDelayInMs" << uma_suffix << " "
+                   << e2e_delay_ms;
+    }
+    int e2e_delay_max_ms = stats.e2e_delay_counter.Max();
+    if (e2e_delay_max_ms != -1 && e2e_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_100000(
+          idx, uma_prefix + ".EndToEndDelayMaxInMs" + uma_suffix,
+          e2e_delay_max_ms);
+      LOG(LS_INFO) << uma_prefix << ".EndToEndDelayMaxInMs" << uma_suffix << " "
+                   << e2e_delay_max_ms;
+    }
+    int interframe_delay_ms =
+        stats.interframe_delay_counter.Avg(kMinRequiredSamples);
+    if (interframe_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".InterframeDelayInMs" + uma_suffix,
+          interframe_delay_ms);
+      LOG(LS_INFO) << uma_prefix << ".InterframeDelayInMs" << uma_suffix << " "
+                   << interframe_delay_ms;
+    }
+    int interframe_delay_max_ms = stats.interframe_delay_counter.Max();
+    if (interframe_delay_max_ms != -1 && interframe_delay_ms != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".InterframeDelayMaxInMs" + uma_suffix,
+          interframe_delay_max_ms);
+      LOG(LS_INFO) << uma_prefix << ".InterframeDelayMaxInMs" << uma_suffix
+                   << " " << interframe_delay_max_ms;
+    }
+
+    float flow_duration_sec = stats.flow_duration_ms / 1000.0;
+    if (flow_duration_sec >= metrics::kMinRunTimeInSeconds) {
+      int media_bitrate_kbps = static_cast<int>(stats.total_media_bytes * 8 /
+                                                flow_duration_sec / 1000);
+      RTC_HISTOGRAM_COUNTS_10000(
+          uma_prefix + ".MediaBitrateReceivedInKbps" + uma_suffix,
+          media_bitrate_kbps);
+      LOG(LS_INFO) << uma_prefix << ".MediaBitrateReceivedInKbps" << uma_suffix
+                   << " " << media_bitrate_kbps;
+    }
+
+    int qp = stats.qp_counter.Avg(kMinRequiredSamples);
+    if (qp != -1) {
+      RTC_HISTOGRAMS_COUNTS_200(
+          idx, uma_prefix + ".Decoded.Vp8.Qp" + uma_suffix, qp);
+      LOG(LS_INFO) << uma_prefix << ".Decoded.Vp8.Qp" << uma_suffix << " "
+                   << qp;
+    }
+
+    int width = stats.received_width.Avg(kMinRequiredSamples);
+    if (width != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".ReceivedWidthInPixels" + uma_suffix, width);
+      LOG(LS_INFO) << uma_prefix << ".ReceivedWidthInPixels" << uma_suffix
+                   << " " << width;
+    }
+
+    int height = stats.received_height.Avg(kMinRequiredSamples);
+    if (height != -1) {
+      RTC_HISTOGRAMS_COUNTS_10000(
+          idx, uma_prefix + ".ReceivedHeightInPixels" + uma_suffix, height);
+      LOG(LS_INFO) << uma_prefix << ".ReceivedHeightInPixels" << uma_suffix
+                   << " " << height;
+    }
+  }
+
+  std::string uma_prefix = UmaPrefixForContentType(last_content_type_);
+  std::string uma_experiment_suffix =
+      UmaExperimentSuffixConentType(last_content_type_);

[sprang_webrtc, 2017/08/25 13:56:29]

I think these might unfortunately change during the call. We might not
necessarily negotiate a new receive stream when the source changes. :/

[ilnik, 2017/08/25 14:14:27]

Done.

+  int idx = (last_content_type_.IsScreenshare() ? 1 : 0) +
+            (last_content_type_.GetExperimentId() << 1);
+
+  if (first_report_block_time_ms_ != -1 &&
+      ((clock_->TimeInMilliseconds() - first_report_block_time_ms_) / 1000) >=
+          metrics::kMinRunTimeInSeconds) {
+    int fraction_lost = report_block_stats_.FractionLostInPercent();
+    if (fraction_lost != -1) {
+      RTC_HISTOGRAMS_PERCENTAGE(
+          idx,
+          uma_prefix + ".ReceivedPacketsLostInPercent" + uma_experiment_suffix,
+          fraction_lost);
+      LOG(LS_INFO) << uma_prefix << ".ReceivedPacketsLostInPercent"
+                   << uma_experiment_suffix << " " << fraction_lost;
+    }
+  }
+
+  int stream_duration_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
+  RTC_HISTOGRAMS_COUNTS_100000(
+      idx,
+      uma_prefix + ".ReceiveStreamLifetimeInSeconds" + uma_experiment_suffix,
+      stream_duration_sec);
+  LOG(LS_INFO) << uma_prefix << ".ReceiveStreamLifetimeInSeconds"
+               << uma_experiment_suffix << " " << stream_duration_sec;
+
+  int e2e_delay_ms = e2e_delay_counter.Avg(kMinRequiredSamples);
+  if (e2e_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".EndToEndDelayInMs" + uma_experiment_suffix,
+        e2e_delay_ms);
+    LOG(LS_INFO) << uma_prefix << ".EndToEndDelayInMs" << uma_experiment_suffix
+                 << " " << e2e_delay_ms;
+  }
+  int e2e_delay_max_ms = e2e_delay_counter.Max();
+  if (e2e_delay_max_ms != -1 && e2e_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_100000(
+        idx, uma_prefix + ".EndToEndDelayMaxInMs" + uma_experiment_suffix,
+        e2e_delay_max_ms);
+    LOG(LS_INFO) << uma_prefix << ".EndToEndDelayMaxInMs"
+                 << uma_experiment_suffix << " " << e2e_delay_max_ms;
+  }
+  int interframe_delay_ms = interframe_delay_counter.Avg(kMinRequiredSamples);
+  if (interframe_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".InterframeDelayInMs" + uma_experiment_suffix,
+        interframe_delay_ms);
+    LOG(LS_INFO) << uma_prefix << ".InterframeDelayInMs"
+                 << uma_experiment_suffix << " " << interframe_delay_ms;
+  }
+  int interframe_delay_max_ms = interframe_delay_counter.Max();
+  if (interframe_delay_max_ms != -1 && interframe_delay_ms != -1) {
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".InterframeDelayMaxInMs" + uma_experiment_suffix,
+        interframe_delay_max_ms);
+    LOG(LS_INFO) << uma_prefix << ".InterframeDelayMaxInMs"
+                 << uma_experiment_suffix << " " << interframe_delay_max_ms;
+  }
+
   int width = render_width_counter_.Avg(kMinRequiredSamples);
   int height = render_height_counter_.Avg(kMinRequiredSamples);
   if (width != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.ReceivedWidthInPixels", width);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.ReceivedHeightInPixels", height);
-    LOG(LS_INFO) << "WebRTC.Video.ReceivedWidthInPixels " << width;
-    LOG(LS_INFO) << "WebRTC.Video.ReceivedHeightInPixels " << height;
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".ReceivedWidthInPixels" + uma_experiment_suffix,
+        width);
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".ReceivedHeightInPixels" + uma_experiment_suffix,
+        height);
+    LOG(LS_INFO) << uma_prefix << ".ReceivedWidthInPixels"
+                 << uma_experiment_suffix << " " << width;
+    LOG(LS_INFO) << uma_prefix << ".ReceivedHeightInPixels"
+                 << uma_experiment_suffix << " " << height;
   }
   int sync_offset_ms = sync_offset_counter_.Avg(kMinRequiredSamples);
   if (sync_offset_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs", sync_offset_ms);
     LOG(LS_INFO) << "WebRTC.Video.AVSyncOffsetInMs " << sync_offset_ms;
   }
   AggregatedStats freq_offset_stats = freq_offset_counter_.GetStats();
   if (freq_offset_stats.num_samples > 0) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtpToNtpFreqOffsetInKhz",
                                freq_offset_stats.average);
     LOG(LS_INFO) << "WebRTC.Video.RtpToNtpFreqOffsetInKhz, "
                  << freq_offset_stats.ToString();
   }
 
   int num_total_frames =
       stats_.frame_counts.key_frames + stats_.frame_counts.delta_frames;
   if (num_total_frames >= kMinRequiredSamples) {
     int num_key_frames = stats_.frame_counts.key_frames;
     int key_frames_permille =
         (num_key_frames * 1000 + num_total_frames / 2) / num_total_frames;
-    RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesReceivedInPermille",
-                              key_frames_permille);
-    LOG(LS_INFO) << "WebRTC.Video.KeyFramesReceivedInPermille "
-                 << key_frames_permille;
+    RTC_HISTOGRAMS_COUNTS_1000(
+        idx,
+        uma_prefix + ".KeyFramesReceivedInPermille" + uma_experiment_suffix,
+        key_frames_permille);
+    LOG(LS_INFO) << uma_prefix << ".KeyFramesReceivedInPermille"
+                 << uma_experiment_suffix << " " << key_frames_permille;
   }
 
   int qp = qp_counters_.vp8.Avg(kMinRequiredSamples);
   if (qp != -1) {
-    RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", qp);
-    LOG(LS_INFO) << "WebRTC.Video.Decoded.Vp8.Qp " << qp;
+    RTC_HISTOGRAMS_COUNTS_200(
+        idx, uma_prefix + ".Decoded.Vp8.Qp" + uma_experiment_suffix, qp);
+    LOG(LS_INFO) << uma_prefix << ".Decoded.Vp8.Qp" << uma_experiment_suffix
+                 << " " << qp;
   }
   int decode_ms = decode_time_counter_.Avg(kMinRequiredSamples);
   if (decode_ms != -1) {
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", decode_ms);
     LOG(LS_INFO) << "WebRTC.Video.DecodeTimeInMs " << decode_ms;
   }
   int jb_delay_ms = jitter_buffer_delay_counter_.Avg(kMinRequiredSamples);
   if (jb_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs",
                                jb_delay_ms);
     LOG(LS_INFO) << "WebRTC.Video.JitterBufferDelayInMs " << jb_delay_ms;
   }
 
   int target_delay_ms = target_delay_counter_.Avg(kMinRequiredSamples);
   if (target_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs", target_delay_ms);
     LOG(LS_INFO) << "WebRTC.Video.TargetDelayInMs " << target_delay_ms;
   }
   int current_delay_ms = current_delay_counter_.Avg(kMinRequiredSamples);
   if (current_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.CurrentDelayInMs",
                                current_delay_ms);
     LOG(LS_INFO) << "WebRTC.Video.CurrentDelayInMs " << current_delay_ms;
   }
   int delay_ms = delay_counter_.Avg(kMinRequiredSamples);
   if (delay_ms != -1)
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.OnewayDelayInMs", delay_ms);
 
-  int e2e_delay_ms_video = e2e_delay_counter_video_.Avg(kMinRequiredSamples);
-  if (e2e_delay_ms_video != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.EndToEndDelayInMs",
-                               e2e_delay_ms_video);
-    LOG(LS_INFO) << "WebRTC.Video.EndToEndDelayInMs " << e2e_delay_ms_video;
-  }
-
-  int e2e_delay_ms_screenshare =
-      e2e_delay_counter_screenshare_.Avg(kMinRequiredSamples);
-  if (e2e_delay_ms_screenshare != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.Screenshare.EndToEndDelayInMs",
-                               e2e_delay_ms_screenshare);
-  }
-
-  int e2e_delay_max_ms_video = e2e_delay_max_ms_video_;
-  if (e2e_delay_max_ms_video != -1) {
-    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.EndToEndDelayMaxInMs",
-                                e2e_delay_max_ms_video);
-  }
-
-  int e2e_delay_max_ms_screenshare = e2e_delay_max_ms_screenshare_;
-  if (e2e_delay_max_ms_screenshare != -1) {
-    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.Screenshare.EndToEndDelayMaxInMs",
-                                e2e_delay_max_ms_screenshare);
-  }
-
-  int interframe_delay_ms_screenshare =
-      interframe_delay_counter_screenshare_.Avg(kMinRequiredSamples);
-  if (interframe_delay_ms_screenshare != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.Screenshare.InterframeDelayInMs",
-                               interframe_delay_ms_screenshare);
-    RTC_DCHECK_GE(interframe_delay_max_ms_screenshare_,
-                  interframe_delay_ms_screenshare);
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.Screenshare.InterframeDelayMaxInMs",
-        interframe_delay_max_ms_screenshare_);
-  }
-
-  int interframe_delay_ms_video =
-      interframe_delay_counter_video_.Avg(kMinRequiredSamples);
-  if (interframe_delay_ms_video != -1) {
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InterframeDelayInMs",
-                               interframe_delay_ms_video);
-    RTC_DCHECK_GE(interframe_delay_max_ms_video_, interframe_delay_ms_video);
-    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InterframeDelayMaxInMs",
-                               interframe_delay_max_ms_video_);
-  }
-
   StreamDataCounters rtp = stats_.rtp_stats;
   StreamDataCounters rtx;
   for (auto it : rtx_stats_)
     rtx.Add(it.second);
   StreamDataCounters rtp_rtx = rtp;
   rtp_rtx.Add(rtx);
   int64_t elapsed_sec =
       rtp_rtx.TimeSinceFirstPacketInMs(clock_->TimeInMilliseconds()) / 1000;
   if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
     RTC_HISTOGRAM_COUNTS_10000(
         "WebRTC.Video.BitrateReceivedInKbps",
         static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
                          1000));
-    RTC_HISTOGRAM_COUNTS_10000(
-        "WebRTC.Video.MediaBitrateReceivedInKbps",
-        static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000));
+    int media_bitrate_kbs =
+        static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000);
+    RTC_HISTOGRAMS_COUNTS_10000(
+        idx, uma_prefix + ".MediaBitrateReceivedInKbps" + uma_experiment_suffix,
+        media_bitrate_kbs);
+    LOG(LS_INFO) << uma_prefix << ".MediaBitrateReceivedInKbps"
+                 << uma_experiment_suffix << " " << media_bitrate_kbs;
     RTC_HISTOGRAM_COUNTS_10000(
         "WebRTC.Video.PaddingBitrateReceivedInKbps",
         static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec /
                          1000));
     RTC_HISTOGRAM_COUNTS_10000(
         "WebRTC.Video.RetransmittedBitrateReceivedInKbps",
         static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 / elapsed_sec /
                          1000));
     if (!rtx_stats_.empty()) {
       RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtxBitrateReceivedInKbps",
@@ skipping 254 matching lines @@
   }
   if (total_bytes > last_total_bytes)
     total_byte_tracker_.AddSamples(total_bytes - last_total_bytes);
 }
 
 void ReceiveStatisticsProxy::OnDecodedFrame(rtc::Optional<uint8_t> qp,
                                             VideoContentType content_type) {
   uint64_t now = clock_->TimeInMilliseconds();
 
   rtc::CritScope lock(&crit_);
+
+  ContentSpecificStats* content_specific_stats =
+      &content_specific_stats_[content_type];
   ++stats_.frames_decoded;
   if (qp) {
     if (!stats_.qp_sum) {
       if (stats_.frames_decoded != 1) {
         LOG(LS_WARNING)
             << "Frames decoded was not 1 when first qp value was received.";
         stats_.frames_decoded = 1;
       }
       stats_.qp_sum = rtc::Optional<uint64_t>(0);
     }
     *stats_.qp_sum += *qp;
+    content_specific_stats->qp_counter.Add(*qp);
   } else if (stats_.qp_sum) {
     LOG(LS_WARNING)
         << "QP sum was already set and no QP was given for a frame.";
     stats_.qp_sum = rtc::Optional<uint64_t>();
   }
   last_content_type_ = content_type;
   decode_fps_estimator_.Update(1, now);
   if (last_decoded_frame_time_ms_) {
     int64_t interframe_delay_ms = now - *last_decoded_frame_time_ms_;
     RTC_DCHECK_GE(interframe_delay_ms, 0);
     stats_.interframe_delay_sum_ms += interframe_delay_ms;
-    if (last_content_type_ == VideoContentType::SCREENSHARE) {
-      interframe_delay_counter_screenshare_.Add(interframe_delay_ms);
-      if (interframe_delay_max_ms_screenshare_ < interframe_delay_ms) {
-        interframe_delay_max_ms_screenshare_ = interframe_delay_ms;
-      }
-    } else {
-      interframe_delay_counter_video_.Add(interframe_delay_ms);
-      if (interframe_delay_max_ms_video_ < interframe_delay_ms) {
-        interframe_delay_max_ms_video_ = interframe_delay_ms;
-      }
-    }
+    content_specific_stats->interframe_delay_counter.Add(interframe_delay_ms);
+    content_specific_stats->flow_duration_ms += interframe_delay_ms;
+    interframe_delay_counter.Add(interframe_delay_ms);
   }
   last_decoded_frame_time_ms_.emplace(now);
 }
 
 void ReceiveStatisticsProxy::OnRenderedFrame(const VideoFrame& frame) {
   int width = frame.width();
   int height = frame.height();
   RTC_DCHECK_GT(width, 0);
   RTC_DCHECK_GT(height, 0);
   uint64_t now = clock_->TimeInMilliseconds();
-
   rtc::CritScope lock(&crit_);
+  ContentSpecificStats* content_specific_stats =
+      &content_specific_stats_[last_content_type_];
   renders_fps_estimator_.Update(1, now);
   ++stats_.frames_rendered;
   stats_.width = width;
   stats_.height = height;
   render_width_counter_.Add(width);
   render_height_counter_.Add(height);
   render_fps_tracker_.AddSamples(1);
   render_pixel_tracker_.AddSamples(sqrt(width * height));
+  content_specific_stats->received_width.Add(width);
+  content_specific_stats->received_height.Add(height);
 
   if (frame.ntp_time_ms() > 0) {
     int64_t delay_ms = clock_->CurrentNtpInMilliseconds() - frame.ntp_time_ms();
     if (delay_ms >= 0) {
-      if (last_content_type_ == VideoContentType::SCREENSHARE) {
-        e2e_delay_max_ms_screenshare_ =
-            std::max(delay_ms, e2e_delay_max_ms_screenshare_);
-        e2e_delay_counter_screenshare_.Add(delay_ms);
-      } else {
-        e2e_delay_max_ms_video_ = std::max(delay_ms, e2e_delay_max_ms_video_);
-        e2e_delay_counter_video_.Add(delay_ms);
-      }
+      content_specific_stats->e2e_delay_counter.Add(delay_ms);
+      e2e_delay_counter.Add(delay_ms);
     }
   }
 }
 
 void ReceiveStatisticsProxy::OnSyncOffsetUpdated(int64_t sync_offset_ms,
                                                  double estimated_freq_khz) {
   rtc::CritScope lock(&crit_);
   sync_offset_counter_.Add(std::abs(sync_offset_ms));
   stats_.sync_offset_ms = sync_offset_ms;
 
@@ skipping 11 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;
 
+  // Todo(ilnik): May be incorrect for the first frame of a new content type
+  // stream. Leads to a bit incorrect |total_media_bytes| count.
+  ContentSpecificStats* content_specific_stats =
+      &content_specific_stats_[last_content_type_];
+
+  content_specific_stats->total_media_bytes += size_bytes;
+
   int64_t now_ms = clock_->TimeInMilliseconds();
   frame_window_.insert(std::make_pair(now_ms, size_bytes));
   UpdateFramerate(now_ms);
 }
 
 void ReceiveStatisticsProxy::OnFrameCountsUpdated(
     const FrameCounts& frame_counts) {
   rtc::CritScope lock(&crit_);
   stats_.frame_counts = frame_counts;
 }
@@ skipping 20 matching lines @@
   // TODO(sprang): Figure out any other state that should be reset.
 
   rtc::CritScope lock(&crit_);
   // Don't report inter-frame delay if stream was paused.
   last_decoded_frame_time_ms_.reset();
 }
 
 void ReceiveStatisticsProxy::SampleCounter::Add(int sample) {
   sum += sample;
   ++num_samples;
+  if (!max || *max < sample) {
+    max.emplace(sample);
+  }
 }
 
 int ReceiveStatisticsProxy::SampleCounter::Avg(
     int64_t min_required_samples) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>(sum / num_samples);
 }
 
+int ReceiveStatisticsProxy::SampleCounter::Max() const {
+  if (!max) {
+    return -1;
+  } else {
+    return *max;
+  }
+}
+
 void ReceiveStatisticsProxy::SampleCounter::Reset() {
   num_samples = 0;
   sum = 0;
+  max.reset();
 }
 
 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