Update video adaptation stats to support degradations in both resolution and framerate.

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 278 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);
     }
   }
 
   if (first_rtp_stats_time_ms_ != -1) {
-    quality_scaling_timer_.Stop(clock_->TimeInMilliseconds());
-    int64_t elapsed_sec = quality_scaling_timer_.total_ms / 1000;
+    quality_adapt_timer_.Stop(clock_->TimeInMilliseconds());
+    int64_t elapsed_sec = quality_adapt_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;
+    cpu_adapt_timer_.Stop(clock_->TimeInMilliseconds());
+    elapsed_sec = cpu_adapt_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) {
@@ skipping 168 matching lines @@
     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);
+    uma_container_->cpu_adapt_timer_.Stop(now_ms);
+    uma_container_->quality_adapt_timer_.Stop(now_ms);
   } else {
     // Start adaptation stats if scaling is enabled.
     if (cpu_downscales_ >= 0)
-      uma_container_->cpu_scaling_timer_.Start(now_ms);
+      uma_container_->cpu_adapt_timer_.Start(now_ms);
     if (quality_downscales_ >= 0)
-      uma_container_->quality_scaling_timer_.Start(now_ms);
+      uma_container_->quality_adapt_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 196 matching lines @@
   if (cpu_downscales_ >= 0) {
     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) {
+void SendStatisticsProxy::SetAdaptationStats(
+    const ViEEncoder::AdaptCounts& cpu_counts,
+    const ViEEncoder::AdaptCounts& quality_counts) {
   rtc::CritScope lock(&crit_);
-  cpu_downscales_ = num_cpu_downscales;
-  stats_.cpu_limited_resolution = num_cpu_downscales > 0;
-
-  if (num_cpu_downscales >= 0) {
-    // Scaling enabled.
-    if (!stats_.suspended)
-      uma_container_->cpu_scaling_timer_.Start(clock_->TimeInMilliseconds());
-    return;
-  }
-  uma_container_->cpu_scaling_timer_.Stop(clock_->TimeInMilliseconds());
+  SetAdaptTimer(cpu_counts, &uma_container_->cpu_adapt_timer_);
+  SetAdaptTimer(quality_counts, &uma_container_->quality_adapt_timer_);
+  UpdateAdaptationStats(cpu_counts, quality_counts);
 }
 
-void SendStatisticsProxy::SetQualityScalingStats(int num_quality_downscales) {
+void SendStatisticsProxy::OnCpuAdaptationChanged(
+    const ViEEncoder::AdaptCounts& cpu_counts,
+    const ViEEncoder::AdaptCounts& quality_counts) {
   rtc::CritScope lock(&crit_);
-  quality_downscales_ = num_quality_downscales;
-  stats_.bw_limited_resolution = quality_downscales_ > 0;
-
-  if (num_quality_downscales >= 0) {
-    // Scaling enabled.
-    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;
+  UpdateAdaptationStats(cpu_counts, quality_counts);
   TRACE_EVENT_INSTANT0("webrtc_stats", "WebRTC.Video.CpuAdaptationChanges");
 }
 
-void SendStatisticsProxy::OnQualityRestrictedResolutionChanged(
-    int num_quality_downscales) {
+void SendStatisticsProxy::OnQualityAdaptationChanged(
+    const ViEEncoder::AdaptCounts& cpu_counts,
+    const ViEEncoder::AdaptCounts& quality_counts) {
   rtc::CritScope lock(&crit_);
   ++stats_.number_of_quality_adapt_changes;
-  quality_downscales_ = num_quality_downscales;
-  stats_.bw_limited_resolution = quality_downscales_ > 0;
+  UpdateAdaptationStats(cpu_counts, quality_counts);
+}
+
+void SendStatisticsProxy::UpdateAdaptationStats(
+    const ViEEncoder::AdaptCounts& cpu_counts,
+    const ViEEncoder::AdaptCounts& quality_counts) {
+  cpu_downscales_ = cpu_counts.resolution;
+  quality_downscales_ = quality_counts.resolution;
+
+  stats_.cpu_limited_resolution = cpu_counts.resolution > 0;
+  stats_.cpu_limited_framerate = cpu_counts.fps > 0;
+  stats_.bw_limited_resolution = quality_counts.resolution > 0;
+  stats_.bw_limited_framerate = quality_counts.fps > 0;
+}
+
+void SendStatisticsProxy::SetAdaptTimer(const ViEEncoder::AdaptCounts& counts,
+                                        StatsTimer* timer) {
+  if (counts.resolution >= 0 || counts.fps >= 0) {
+    // Adaptation enabled.
+    if (!stats_.suspended)
+      timer->Start(clock_->TimeInMilliseconds());
+    return;
+  }
+  timer->Stop(clock_->TimeInMilliseconds());
 }
 
 void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
     uint32_t ssrc,
     const RtcpPacketTypeCounter& packet_counter) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (!stats)
     return;
 
@@ skipping 35 matching lines @@
   if (stats->is_flexfec) {
     // The same counters are reported for both the media ssrc and flexfec ssrc.
     // Bitrate stats are summed for all SSRCs. Use fec stats from media update.
     return;
   }
 
   stats->rtp_stats = counters;
   if (uma_container_->first_rtp_stats_time_ms_ == -1) {
     int64_t now_ms = clock_->TimeInMilliseconds();
     uma_container_->first_rtp_stats_time_ms_ = now_ms;
-    uma_container_->cpu_scaling_timer_.Restart(now_ms);
-    uma_container_->quality_scaling_timer_.Restart(now_ms);
+    uma_container_->cpu_adapt_timer_.Restart(now_ms);
+    uma_container_->quality_adapt_timer_.Restart(now_ms);
   }
 
   uma_container_->total_byte_counter_.Set(counters.transmitted.TotalBytes(),
                                           ssrc);
   uma_container_->padding_byte_counter_.Set(counters.transmitted.padding_bytes,
                                             ssrc);
   uma_container_->retransmit_byte_counter_.Set(
       counters.retransmitted.TotalBytes(), ssrc);
   uma_container_->fec_byte_counter_.Set(counters.fec.TotalBytes(), ssrc);
   if (stats->is_rtx) {
@@ skipping 95 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