Add scrolling screenshare test to full_stack perf tests.

webrtc/video/full_stack.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 <stdio.h>
@@ skipping 22 matching lines @@
 #include "webrtc/test/frame_generator_capturer.h"
 #include "webrtc/test/statistics.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 static const int kFullStackTestDurationSecs = 60;
 static const int kSendStatsPollingIntervalMs = 1000;
 
+enum class ContentMode {
+  kRealTimeVideo,
+  kScreensharingStaticImage,
+  kScreensharingScrollingImage,
+};
+
 struct FullStackTestParams {
   const char* test_label;
   struct {
     const char* name;
     size_t width, height;
     int fps;
   } clip;
-  bool screenshare;
+  ContentMode mode;
   int min_bitrate_bps;
   int target_bitrate_bps;
   int max_bitrate_bps;
   double avg_psnr_threshold;
   double avg_ssim_threshold;
   int test_durations_secs;
   std::string codec;
   FakeNetworkPipe::Config link;
 };
 
@@ skipping 463 matching lines @@
   VideoStream* stream = &encoder_config_.streams[0];
   stream->width = params.clip.width;
   stream->height = params.clip.height;
   stream->min_bitrate_bps = params.min_bitrate_bps;
   stream->target_bitrate_bps = params.target_bitrate_bps;
   stream->max_bitrate_bps = params.max_bitrate_bps;
   stream->max_framerate = params.clip.fps;
 
   VideoCodecVP8 vp8_settings;
   VideoCodecVP9 vp9_settings;
-  if (params.screenshare) {
+  if (params.mode == ContentMode::kScreensharingStaticImage ||
+      params.mode == ContentMode::kScreensharingScrollingImage) {
     encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
     encoder_config_.min_transmit_bitrate_bps = 400 * 1000;
     if (params.codec == "VP8") {
       vp8_settings = VideoEncoder::GetDefaultVp8Settings();
       vp8_settings.denoisingOn = false;
       vp8_settings.frameDroppingOn = false;
       vp8_settings.numberOfTemporalLayers = 2;
       encoder_config_.encoder_specific_settings = &vp8_settings;
     } else if (params.codec == "VP9") {
       vp9_settings = VideoEncoder::GetDefaultVp9Settings();
@@ skipping 13 matching lines @@
   receive_configs_[0].rtp.rtx[kSendRtxPayloadType].ssrc = kSendRtxSsrcs[0];
   receive_configs_[0].rtp.rtx[kSendRtxPayloadType].payload_type =
       kSendRtxPayloadType;
 
   for (auto& config : receive_configs_)
     config.pre_decode_callback = &analyzer;
   CreateStreams();
   analyzer.input_ = send_stream_->Input();
   analyzer.send_stream_ = send_stream_;
 
-  if (params.screenshare) {
-    std::vector<std::string> slides;
-    slides.push_back(test::ResourcePath("web_screenshot_1850_1110", "yuv"));
-    slides.push_back(test::ResourcePath("presentation_1850_1110", "yuv"));
-    slides.push_back(test::ResourcePath("photo_1850_1110", "yuv"));
-    slides.push_back(test::ResourcePath("difficult_photo_1850_1110", "yuv"));
+  std::vector<std::string> slides;
+  slides.push_back(test::ResourcePath("web_screenshot_1850_1110", "yuv"));
+  slides.push_back(test::ResourcePath("presentation_1850_1110", "yuv"));
+  slides.push_back(test::ResourcePath("photo_1850_1110", "yuv"));
+  slides.push_back(test::ResourcePath("difficult_photo_1850_1110", "yuv"));
+  size_t kSlidesWidth = 1850;
+  size_t kSlidesHeight = 1110;
 
-    rtc::scoped_ptr<test::FrameGenerator> frame_generator(
-        test::FrameGenerator::CreateFromYuvFile(
-            slides, 1850, 1110,
-            10 * params.clip.fps)  // Cycle image every 10 seconds.
-        );
-    frame_generator_capturer_.reset(new test::FrameGeneratorCapturer(
-        Clock::GetRealTimeClock(), &analyzer, frame_generator.release(),
-        params.clip.fps));
-    ASSERT_TRUE(frame_generator_capturer_->Init());
-  } else {
-    frame_generator_capturer_.reset(
-        test::FrameGeneratorCapturer::CreateFromYuvFile(
-            &analyzer, test::ResourcePath(params.clip.name, "yuv"),
-            params.clip.width, params.clip.height, params.clip.fps,
-            Clock::GetRealTimeClock()));
+  Clock* clock = Clock::GetRealTimeClock();
+  rtc::scoped_ptr<test::FrameGenerator> frame_generator;
 
-    ASSERT_TRUE(frame_generator_capturer_.get() != nullptr)
-        << "Could not create capturer for " << params.clip.name
-        << ".yuv. Is this resource file present?";
+  switch (params.mode) {
+    case ContentMode::kRealTimeVideo:
+      frame_generator.reset(test::FrameGenerator::CreateFromYuvFile(
+          std::vector<std::string>(1,
+                                   test::ResourcePath(params.clip.name, "yuv")),
+          params.clip.width, params.clip.height, 1));
+      break;
+    case ContentMode::kScreensharingScrollingImage:
+      frame_generator.reset(
+          test::FrameGenerator::CreateScrollingInputFromYuvFiles(
+              clock, slides, kSlidesWidth, kSlidesHeight, params.clip.width,
+              params.clip.height, 2000,
+              8000));  // Scroll for 2 seconds, then pause for 8.
+      break;
+    case ContentMode::kScreensharingStaticImage:
+      frame_generator.reset(test::FrameGenerator::CreateFromYuvFile(
+          slides, kSlidesWidth, kSlidesHeight,
+          10 * params.clip.fps));  // Cycle image every 10 seconds.
+      break;
   }
 
+  ASSERT_TRUE(frame_generator.get() != nullptr);
+  frame_generator_capturer_.reset(new test::FrameGeneratorCapturer(
+      clock, &analyzer, frame_generator.release(), params.clip.fps));
+  ASSERT_TRUE(frame_generator_capturer_->Init());
+
   Start();
 
   analyzer.Wait();
 
   send_transport.StopSending();
   recv_transport.StopSending();
 
   Stop();
 
   DestroyStreams();
 }
 
 TEST_F(FullStackTest, ParisQcifWithoutPacketLoss) {
   FullStackTestParams paris_qcif = {"net_delay_0_0_plr_0",
                                     {"paris_qcif", 176, 144, 30},
-                                    false,
+                                    ContentMode::kRealTimeVideo,
                                     300000,
                                     300000,
                                     300000,
                                     36.0,
                                     0.96,
                                     kFullStackTestDurationSecs,
                                     "VP8"};
   RunTest(paris_qcif);
 }
 
 TEST_F(FullStackTest, ForemanCifWithoutPacketLoss) {
   // TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
   FullStackTestParams foreman_cif = {"foreman_cif_net_delay_0_0_plr_0",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      700000,
                                      700000,
                                      700000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   RunTest(foreman_cif);
 }
 
 TEST_F(FullStackTest, ForemanCifPlr5) {
   FullStackTestParams foreman_cif = {"foreman_cif_delay_50_0_plr_5",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   foreman_cif.link.loss_percent = 5;
   foreman_cif.link.queue_delay_ms = 50;
   RunTest(foreman_cif);
 }
 
 TEST_F(FullStackTest, ForemanCif500kbps) {
   FullStackTestParams foreman_cif = {"foreman_cif_500kbps",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   foreman_cif.link.queue_length_packets = 0;
   foreman_cif.link.queue_delay_ms = 0;
   foreman_cif.link.link_capacity_kbps = 500;
   RunTest(foreman_cif);
 }
 
 TEST_F(FullStackTest, ForemanCif500kbpsLimitedQueue) {
   FullStackTestParams foreman_cif = {"foreman_cif_500kbps_32pkts_queue",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   foreman_cif.link.queue_length_packets = 32;
   foreman_cif.link.queue_delay_ms = 0;
   foreman_cif.link.link_capacity_kbps = 500;
   RunTest(foreman_cif);
 }
 
 TEST_F(FullStackTest, ForemanCif500kbps100ms) {
   FullStackTestParams foreman_cif = {"foreman_cif_500kbps_100ms",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   foreman_cif.link.queue_length_packets = 0;
   foreman_cif.link.queue_delay_ms = 100;
   foreman_cif.link.link_capacity_kbps = 500;
   RunTest(foreman_cif);
 }
 
 TEST_F(FullStackTest, ForemanCif500kbps100msLimitedQueue) {
   FullStackTestParams foreman_cif = {"foreman_cif_500kbps_100ms_32pkts_queue",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   foreman_cif.link.queue_length_packets = 32;
   foreman_cif.link.queue_delay_ms = 100;
   foreman_cif.link.link_capacity_kbps = 500;
   RunTest(foreman_cif);
 }
 
 TEST_F(FullStackTest, ForemanCif1000kbps100msLimitedQueue) {
   FullStackTestParams foreman_cif = {"foreman_cif_1000kbps_100ms_32pkts_queue",
                                      {"foreman_cif", 352, 288, 30},
-                                     false,
+                                     ContentMode::kRealTimeVideo,
                                      30000,
                                      2000000,
                                      2000000,
                                      0.0,
                                      0.0,
                                      kFullStackTestDurationSecs,
                                      "VP8"};
   foreman_cif.link.queue_length_packets = 32;
   foreman_cif.link.queue_delay_ms = 100;
   foreman_cif.link.link_capacity_kbps = 1000;
   RunTest(foreman_cif);
 }
 
 // Temporarily disabled on Android due to low test timeouts.
 // https://code.google.com/p/chromium/issues/detail?id=513170
 #include "webrtc/test/testsupport/gtest_disable.h"
 TEST_F(FullStackTest, DISABLED_ON_ANDROID(ScreenshareSlidesVP8_2TL)) {
   FullStackTestParams screenshare_params = {
       "screenshare_slides",
       {"screenshare_slides", 1850, 1110, 5},
-      true,
+      ContentMode::kScreensharingStaticImage,
       50000,
       200000,
       2000000,
+      0.0,
+      0.0,
+      kFullStackTestDurationSecs,
+      "VP8"};
+  RunTest(screenshare_params);
+}
+
+TEST_F(FullStackTest, DISABLED_ON_ANDROID(ScreenshareSlidesVP8_2TL_Scroll)) {
+  FullStackTestParams screenshare_params = {
+      "screenshare_slides_scrolling",
+      // Crop height by two, scrolling vertically only.
+      {"screenshare_slides_scrolling", 1850, 1110 / 2, 5},
+      ContentMode::kScreensharingScrollingImage,
+      50000,
+      200000,
+      2000000,
       0.0,
       0.0,
       kFullStackTestDurationSecs,
       "VP8"};
   RunTest(screenshare_params);
 }
 
 // Disabled on Android along with VP8 screenshare above.
 TEST_F(FullStackTest, DISABLED_ON_ANDROID(ScreenshareSlidesVP9_2TL)) {
   FullStackTestParams screenshare_params = {
       "screenshare_slides_vp9_2tl",
       {"screenshare_slides", 1850, 1110, 5},
-      true,
+      ContentMode::kScreensharingStaticImage,
       50000,
       200000,
       2000000,
       0.0,
       0.0,
       kFullStackTestDurationSecs,
       "VP9"};
   RunTest(screenshare_params);
 }
 }  // namespace webrtc