Update stats for cpu/quality adaptation changes to excluded time when video is suspended.

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.
  */
 
@@ skipping 71 matching lines @@
     Clock* clock,
     const VideoSendStream::Config& config,
     VideoEncoderConfig::ContentType content_type)
     : clock_(clock),
       payload_name_(config.encoder_settings.payload_name),
       rtp_config_(config.rtp),
       content_type_(content_type),
       start_ms_(clock->TimeInMilliseconds()),
       last_sent_frame_timestamp_(0),
       encode_time_(kEncodeTimeWeigthFactor),
+      quality_downscales_(-1),
+      cpu_downscales_(-1),
       uma_container_(
           new UmaSamplesContainer(GetUmaPrefix(content_type_), stats_, clock)) {
 }
 
 SendStatisticsProxy::~SendStatisticsProxy() {
   rtc::CritScope lock(&crit_);
   uma_container_->UpdateHistograms(rtp_config_, stats_);
 
   int64_t elapsed_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
   RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.SendStreamLifetimeInSeconds",
@@ skipping 184 matching lines @@
     }
     int qp_h264 = it.second.h264.Avg(kMinRequiredMetricsSamples);
     if (qp_h264 != -1) {
       int spatial_idx = it.first;
       RTC_DCHECK_EQ(-1, spatial_idx);
       RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "Encoded.Qp.H264",
                                 qp_h264);
     }
   }
 
-  quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
-  int64_t elapsed_sec = quality_scaling_timer_.total_ms / 1000;
-  if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
-    int quality_changes = current_stats.number_of_quality_adapt_changes -
-                          start_stats_.number_of_quality_adapt_changes;
-    RTC_HISTOGRAMS_COUNTS_100(kIndex,
-                              uma_prefix_ + "AdaptChangesPerMinute.Quality",
-                              quality_changes * 60 / elapsed_sec);
-  }
-  cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
-  elapsed_sec = cpu_scaling_timer_.total_ms / 1000;
-  if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
-    int cpu_changes = current_stats.number_of_cpu_adapt_changes -
-                      start_stats_.number_of_cpu_adapt_changes;
-    RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "AdaptChangesPerMinute.Cpu",
-                              cpu_changes * 60 / elapsed_sec);
+  if (first_rtp_stats_time_ms_ != -1) {
+    quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+    int64_t elapsed_sec = quality_scaling_timer_.total_ms / 1000;
+    if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
+      int quality_changes = current_stats.number_of_quality_adapt_changes -
+                            start_stats_.number_of_quality_adapt_changes;
+      RTC_HISTOGRAMS_COUNTS_100(kIndex,
+                                uma_prefix_ + "AdaptChangesPerMinute.Quality",
+                                quality_changes * 60 / elapsed_sec);
+    }
+    cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+    elapsed_sec = cpu_scaling_timer_.total_ms / 1000;
+    if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
+      int cpu_changes = current_stats.number_of_cpu_adapt_changes -
+                        start_stats_.number_of_cpu_adapt_changes;
+      RTC_HISTOGRAMS_COUNTS_100(kIndex,
+                                uma_prefix_ + "AdaptChangesPerMinute.Cpu",
+                                cpu_changes * 60 / elapsed_sec);
+    }
   }
 
   if (first_rtcp_stats_time_ms_ != -1) {
     int64_t elapsed_sec =
         (clock_->TimeInMilliseconds() - first_rtcp_stats_time_ms_) / 1000;
     if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
       int fraction_lost = report_block_stats_.FractionLostInPercent();
       if (fraction_lost != -1) {
         RTC_HISTOGRAMS_PERCENTAGE(
             kIndex, uma_prefix_ + "SentPacketsLostInPercent", fraction_lost);
@@ skipping 144 matching lines @@
   stats_.encode_usage_percent = metrics.encode_usage_percent;
   TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.EncodeTimeInMs",
       "encode_time_ms", stats_.avg_encode_time_ms,
       "ssrc", rtp_config_.ssrcs[0]);
   TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.EncodeUsagePercent",
       "encode_usage_percent", stats_.encode_usage_percent,
       "ssrc", rtp_config_.ssrcs[0]);
 }
 
 void SendStatisticsProxy::OnSuspendChange(bool is_suspended) {
+  int64_t now_ms = clock_->TimeInMilliseconds();
   rtc::CritScope lock(&crit_);
   stats_.suspended = is_suspended;
   if (is_suspended) {
     // Pause framerate (add min pause time since there may be frames/packets
     // that are not yet sent).
     const int64_t kMinMs = 500;
     uma_container_->input_fps_counter_.ProcessAndPauseForDuration(kMinMs);
     uma_container_->sent_fps_counter_.ProcessAndPauseForDuration(kMinMs);
     // Pause bitrate stats.
     uma_container_->total_byte_counter_.ProcessAndPauseForDuration(kMinMs);
     uma_container_->media_byte_counter_.ProcessAndPauseForDuration(kMinMs);
     uma_container_->rtx_byte_counter_.ProcessAndPauseForDuration(kMinMs);
     uma_container_->padding_byte_counter_.ProcessAndPauseForDuration(kMinMs);
     uma_container_->retransmit_byte_counter_.ProcessAndPauseForDuration(kMinMs);
     uma_container_->fec_byte_counter_.ProcessAndPauseForDuration(kMinMs);
+    // Stop adaptation stats.
+    uma_container_->cpu_scaling_timer_.Stop(now_ms);
+    uma_container_->quality_scaling_timer_.Stop(now_ms);
   } else {
+    // Start adaptation stats if scaling is enabled.
+    if (cpu_downscales_ >= 0)
+      uma_container_->cpu_scaling_timer_.Start(now_ms);
+    if (quality_downscales_ >= 0)
+      uma_container_->quality_scaling_timer_.Start(now_ms);
     // Stop pause explicitly for stats that may be zero/not updated for some
     // time.
     uma_container_->rtx_byte_counter_.ProcessAndStopPause();
     uma_container_->padding_byte_counter_.ProcessAndStopPause();
     uma_container_->retransmit_byte_counter_.ProcessAndStopPause();
     uma_container_->fec_byte_counter_.ProcessAndStopPause();
   }
 }
 
 VideoSendStream::Stats SendStatisticsProxy::GetStats() {
@@ skipping 195 matching lines @@
   uma_container_->input_height_counter_.Add(height);
   uma_container_->cpu_limited_frame_counter_.Add(stats_.cpu_limited_resolution);
   TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.InputFrameRate",
       "frame_rate", round(
           uma_container_->input_frame_rate_tracker_.ComputeRate()),
       "ssrc", rtp_config_.ssrcs[0]);
 }
 
 void SendStatisticsProxy::SetCpuScalingStats(int num_cpu_downscales) {
   rtc::CritScope lock(&crit_);
+  cpu_downscales_ = num_cpu_downscales;
   stats_.cpu_limited_resolution = num_cpu_downscales > 0;
 
   if (num_cpu_downscales >= 0) {
     // Scaling enabled.
-    uma_container_->cpu_scaling_timer_.Start(clock_->TimeInMilliseconds());
-  } else {
-    uma_container_->cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+    if (!stats_.suspended)
+      uma_container_->cpu_scaling_timer_.Start(clock_->TimeInMilliseconds());
+    return;
   }
+  uma_container_->cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
 }
 
 void SendStatisticsProxy::SetQualityScalingStats(int num_quality_downscales) {
   rtc::CritScope lock(&crit_);
   quality_downscales_ = num_quality_downscales;
   stats_.bw_limited_resolution = quality_downscales_ > 0;
 
   if (num_quality_downscales >= 0) {
     // Scaling enabled.
-    uma_container_->quality_scaling_timer_.Start(clock_->TimeInMilliseconds());
-  } else {
-    uma_container_->quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+    if (!stats_.suspended) {
+      uma_container_->quality_scaling_timer_.Start(
+          clock_->TimeInMilliseconds());
+    }
+    return;
   }
+  uma_container_->quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
 }
 
 void SendStatisticsProxy::OnCpuRestrictedResolutionChanged(
     bool cpu_restricted_resolution) {
   rtc::CritScope lock(&crit_);
   stats_.cpu_limited_resolution = cpu_restricted_resolution;
   ++stats_.number_of_cpu_adapt_changes;
   TRACE_EVENT_INSTANT0("webrtc_stats", "WebRTC.Video.CpuAdaptationChanges");
 }
 
@@ skipping 168 matching lines @@
 }
 
 int SendStatisticsProxy::BoolSampleCounter::Fraction(
     int64_t min_required_samples,
     float multiplier) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>((sum * multiplier / num_samples) + 0.5f);
 }
 }  // namespace webrtc