Add histogram stats for average QP per frame for VP9 (for sent video streams):

webrtc/video/send_statistics_proxy_unittest.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.
  */
 
 // This file includes unit tests for SendStatisticsProxy.
 #include "webrtc/video/send_statistics_proxy.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/test/histogram.h"
 
 namespace webrtc {
+namespace {
+const uint32_t kFirstSsrc = 17;
+const uint32_t kSecondSsrc = 42;
+const uint32_t kFirstRtxSsrc = 18;
+const uint32_t kSecondRtxSsrc = 43;
 
-static const uint32_t kFirstSsrc = 17;
-static const uint32_t kSecondSsrc = 42;
-static const uint32_t kFirstRtxSsrc = 18;
-static const uint32_t kSecondRtxSsrc = 43;
+const int kMinRequiredSamples = 200;
+const int kQpIdx0 = 21;
+const int kQpIdx1 = 39;
+}  // namespace
 
 class SendStatisticsProxyTest : public ::testing::Test {
  public:
   SendStatisticsProxyTest()
       : fake_clock_(1234), config_(GetTestConfig()), avg_delay_ms_(0),
         max_delay_ms_(0) {}
   virtual ~SendStatisticsProxyTest() {}
 
  protected:
   virtual void SetUp() {
@@ skipping 264 matching lines @@
   metrics.encode_usage_percent = 80;
   statistics_proxy_->OnEncodedFrameTimeMeasured(kEncodeTimeMs, metrics);
 
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kEncodeTimeMs, stats.avg_encode_time_ms);
   EXPECT_EQ(metrics.encode_usage_percent, stats.encode_usage_percent);
 }
 
 TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) {
   test::ClearHistograms();
-  const int kMinRequiredSamples = 200;
   const int kWidth = 640;
   const int kHeight = 480;
 
   for (int i = 0; i < kMinRequiredSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
 
   // No switch, stats not should be updated.
   statistics_proxy_->SetContentType(
       VideoEncoderConfig::ContentType::kRealtimeVideo);
   EXPECT_EQ(0, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
 
   // Switch to screenshare, real-time stats should be updated.
   statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8) {
   test::ClearHistograms();
-  const int kMinRequiredSamples = 200;
-  const int kQpIdx0 = 21;
-  const int kQpIdx1 = 39;
   EncodedImage encoded_image;
-
   RTPVideoHeader rtp_video_header;
   rtp_video_header.codec = kRtpVideoVp8;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     rtp_video_header.simulcastIdx = 0;
     encoded_image.qp_ = kQpIdx0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
     rtp_video_header.simulcastIdx = 1;
     encoded_image.qp_ = kQpIdx1;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
   }
   statistics_proxy_.reset();
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8.S0"));
   EXPECT_EQ(kQpIdx0,
             test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8.S0"));
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8.S1"));
   EXPECT_EQ(kQpIdx1,
             test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8.S1"));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8OneSsrc) {
   VideoSendStream::Config config(nullptr);
   config.rtp.ssrcs.push_back(kFirstSsrc);
   statistics_proxy_.reset(new SendStatisticsProxy(
       &fake_clock_, config, VideoEncoderConfig::ContentType::kRealtimeVideo));
 
   test::ClearHistograms();
-  const int kMinRequiredSamples = 200;
-  const int kQpIdx0 = 21;
   EncodedImage encoded_image;
-
   RTPVideoHeader rtp_video_header;
   rtp_video_header.codec = kRtpVideoVp8;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     rtp_video_header.simulcastIdx = 0;
     encoded_image.qp_ = kQpIdx0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
   }
   statistics_proxy_.reset();
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8"));
   EXPECT_EQ(kQpIdx0, test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8"));
 }
 
+TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9) {
+  test::ClearHistograms();
+  EncodedImage encoded_image;
+  RTPVideoHeader rtp_video_header;
+  rtp_video_header.simulcastIdx = 0;
+  rtp_video_header.codec = kRtpVideoVp9;
+  rtp_video_header.codecHeader.VP9.num_spatial_layers = 2;
+
+  for (int i = 0; i < kMinRequiredSamples; ++i) {
+    encoded_image.qp_ = kQpIdx0;
+    rtp_video_header.codecHeader.VP9.spatial_idx = 0;
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+    encoded_image.qp_ = kQpIdx1;
+    rtp_video_header.codecHeader.VP9.spatial_idx = 1;
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+  }
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9.S0"));
+  EXPECT_EQ(kQpIdx0,
+            test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9.S0"));
+  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9.S1"));
+  EXPECT_EQ(kQpIdx1,
+            test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9.S1"));
+}
+
+TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9OneSpatialLayer) {
+  VideoSendStream::Config config(nullptr);
+  config.rtp.ssrcs.push_back(kFirstSsrc);
+  statistics_proxy_.reset(new SendStatisticsProxy(
+      &fake_clock_, config, VideoEncoderConfig::ContentType::kRealtimeVideo));
+
+  test::ClearHistograms();
+  EncodedImage encoded_image;
+  RTPVideoHeader rtp_video_header;
+  rtp_video_header.simulcastIdx = 0;
+  rtp_video_header.codec = kRtpVideoVp9;
+  rtp_video_header.codecHeader.VP9.num_spatial_layers = 1;
+
+  for (int i = 0; i < kMinRequiredSamples; ++i) {
+    encoded_image.qp_ = kQpIdx0;
+    rtp_video_header.codecHeader.VP9.spatial_idx = 0;
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+  }
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9"));
+  EXPECT_EQ(kQpIdx0, test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9"));
+}
+
 TEST_F(SendStatisticsProxyTest, NoSubstreams) {
   uint32_t excluded_ssrc =
       std::max(
           *std::max_element(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end()),
           *std::max_element(config_.rtp.rtx.ssrcs.begin(),
                             config_.rtp.rtx.ssrcs.end())) +
       1;
   // From RtcpStatisticsCallback.
   RtcpStatistics rtcp_stats;
   RtcpStatisticsCallback* rtcp_callback = statistics_proxy_.get();
@@ skipping 313 matching lines @@
 
   EXPECT_EQ(1, test::NumHistogramSamples(
                    "WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
   EXPECT_EQ(static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
                              metrics::kMinRunTimeInSeconds / 1000),
             test::LastHistogramSample(
                 "WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
 }
 
 }  // namespace webrtc