Do not report quality limited resolution stats when quality scaler is disabled.

WebRTC.Video.QualityLimitedResolutionInPercent is reported as zero for calls when the quality scaler is off (and the degradation preference allows scaling).

Update SetResolutionRestrictionStats to specify if quality scaler is enabled.

BUG=webrtc:7432

Review-Url: https://codereview.webrtc.org/2783213002
Cr-Commit-Position: refs/heads/master@{#17487}

webrtc/video/send_statistics_proxy.cc

@@ -677,20 +677,15 @@ void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
       "ssrc", rtp_config_.ssrcs[0]);
 }
 
-void SendStatisticsProxy::SetResolutionRestrictionStats(
+void SendStatisticsProxy::SetCpuScalingStats(bool cpu_restricted_resolution) {
-    bool scaling_enabled,
+  rtc::CritScope lock(&crit_);
-    bool cpu_restricted,
+  stats_.cpu_limited_resolution = cpu_restricted_resolution;
-    int num_quality_downscales) {
+}
+
+void SendStatisticsProxy::SetQualityScalingStats(int num_quality_downscales) {
   rtc::CritScope lock(&crit_);
-  if (scaling_enabled) {
   quality_downscales_ = num_quality_downscales;
   stats_.bw_limited_resolution = quality_downscales_ > 0;
-    stats_.cpu_limited_resolution = cpu_restricted;
-  } else {
-    stats_.bw_limited_resolution = false;
-    stats_.cpu_limited_resolution = false;
-    quality_downscales_ = -1;
-  }
 }
 
 void SendStatisticsProxy::OnCpuRestrictedResolutionChanged(

webrtc/video/send_statistics_proxy.h

@@ -59,9 +59,8 @@ class SendStatisticsProxy : public CpuOveruseMetricsObserver,
 
   void OnCpuRestrictedResolutionChanged(bool cpu_restricted_resolution);
   void OnQualityRestrictedResolutionChanged(int num_quality_downscales);
-  void SetResolutionRestrictionStats(bool scaling_enabled,
+  void SetCpuScalingStats(bool cpu_restricted_resolution);
-                                     bool cpu_restricted,
+  void SetQualityScalingStats(int num_quality_downscales);  // -1: disabled.
-                                     int num_quality_downscales);
 
   void OnEncoderStatsUpdate(uint32_t framerate, uint32_t bitrate);
   void OnSuspendChange(bool is_suspended);

webrtc/video/send_statistics_proxy_unittest.cc

@@ -367,6 +367,24 @@ TEST_F(SendStatisticsProxyTest, OnSendEncodedImageWithoutQpQpSumWontExist) {
   EXPECT_EQ(rtc::Optional<uint64_t>(), statistics_proxy_->GetStats().qp_sum);
 }
 
+TEST_F(SendStatisticsProxyTest, SetCpuScalingUpdatesStats) {
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+  statistics_proxy_->SetCpuScalingStats(true);
+  EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
+  statistics_proxy_->SetCpuScalingStats(false);
+  EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
+}
+
+TEST_F(SendStatisticsProxyTest, SetQualityScalingUpdatesStats) {
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  statistics_proxy_->SetQualityScalingStats(-1);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  statistics_proxy_->SetQualityScalingStats(0);
+  EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
+  statistics_proxy_->SetQualityScalingStats(1);
+  EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
+}
+
 TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) {
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
@@ -779,9 +797,9 @@ TEST_F(SendStatisticsProxyTest,
 
 TEST_F(SendStatisticsProxyTest,
        QualityLimitedHistogramsNotUpdatedWhenDisabled) {
+  const int kNumDownscales = -1;
   EncodedImage encoded_image;
-  statistics_proxy_->SetResolutionRestrictionStats(false /* scaling_enabled */,
+  statistics_proxy_->SetQualityScalingStats(kNumDownscales);
-                                                   0, 0);
   for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
     statistics_proxy_->OnSendEncodedImage(encoded_image, &kDefaultCodecInfo);
 

webrtc/video/vie_encoder.cc

@@ -461,13 +461,15 @@ void ViEEncoder::ConfigureQualityScaler() {
   const auto scaling_settings = settings_.encoder->GetScalingSettings();
   const bool degradation_preference_allows_scaling =
       degradation_preference_ != DegradationPreference::kMaintainResolution;
+  const bool quality_scaling_allowed =
+      degradation_preference_allows_scaling && scaling_settings.enabled;
 
-  stats_proxy_->SetResolutionRestrictionStats(
+  stats_proxy_->SetCpuScalingStats(
-      degradation_preference_allows_scaling, scale_counter_[kCpu] > 0,
+      degradation_preference_allows_scaling ? scale_counter_[kCpu] > 0 : false);
-      scale_counter_[kQuality]);
+  stats_proxy_->SetQualityScalingStats(
+      quality_scaling_allowed ? scale_counter_[kQuality] : -1);
 
-  if (degradation_preference_allows_scaling &&
+  if (quality_scaling_allowed) {
-      scaling_settings.enabled) {
     // Abort if quality scaler has already been configured.
     if (quality_scaler_.get() != nullptr)
       return;

webrtc/video/vie_encoder_unittest.cc

@@ -930,6 +930,48 @@ TEST_F(ViEEncoderTest, SwitchingSourceKeepsQualityAdaptation) {
   vie_encoder_->Stop();
 }
 
+TEST_F(ViEEncoderTest, QualityAdaptationStatsAreResetWhenScalerIsDisabled) {
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  const int kWidth = 1280;
+  const int kHeight = 720;
+  video_source_.set_adaptation_enabled(true);
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(1);
+  EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
+
+  // Trigger adapt down.
+  vie_encoder_->TriggerQualityLow();
+  video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(2);
+  EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
+
+  // Trigger overuse.
+  vie_encoder_->TriggerCpuOveruse();
+  video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(3);
+  EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
+
+  // Set source with adaptation still enabled but quality scaler is off.
+  fake_encoder_.SetQualityScaling(false);
+  vie_encoder_->SetSource(&video_source_,
+                          VideoSendStream::DegradationPreference::kBalanced);
+
+  video_source_.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(4);
+  EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
+  EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
+  EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
+
+  vie_encoder_->Stop();
+}
+
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStatsWhenSwitchingSource) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);