Added FullStack performance test for screensharing with VP9

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 34 matching lines @@
     size_t width, height;
     int fps;
   } clip;
   bool screenshare;
   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;
 };
 
 class FullStackTest : public test::CallTest {
  protected:
   void RunTest(const FullStackTestParams& params);
 };
 
 class VideoAnalyzer : public PacketReceiver,
                       public newapi::Transport,
@@ skipping 135 matching lines @@
 
   bool IsTextureSupported() const override { return false; }
 
   void Wait() {
     // Frame comparisons can be very expensive. Wait for test to be done, but
     // at time-out check if frames_processed is going up. If so, give it more
     // time, otherwise fail. Hopefully this will reduce test flakiness.
 
     int last_frames_processed = -1;
     EventTypeWrapper eventType;
-    while ((eventType = done_->Wait(FullStackTest::kDefaultTimeoutMs)) !=
-           kEventSignaled) {
+#ifdef WEBRTC_ANDROID

[pbos-webrtc, 2015/07/13 09:34:43]

not lgtm, can you use kLongTimeoutMs for both instead?

+    int factor = 2;
+#else
+    int factor = 1;
+#endif
+    while ((eventType = done_->Wait(
+            factor * FullStackTest::kDefaultTimeoutMs)) != kEventSignaled) {
       int frames_processed;
       {
         rtc::CritScope crit(&comparison_lock_);
         frames_processed = frames_processed_;
       }
       if (last_frames_processed == -1) {
         last_frames_processed = frames_processed;
         continue;
       }
       ASSERT_GT(frames_processed, last_frames_processed)
@@ skipping 212 matching lines @@
                          params.test_durations_secs * params.clip.fps);
 
   CreateCalls(Call::Config(&analyzer), Call::Config(&recv_transport));
 
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1);
 
-  rtc::scoped_ptr<VideoEncoder> encoder(
-      VideoEncoder::Create(VideoEncoder::kVp8));
-  send_config_.encoder_settings.encoder = encoder.get();
-  send_config_.encoder_settings.payload_name = "VP8";
+  rtc::scoped_ptr<VideoEncoder> encoder;
+  if (params.codec == "VP8") {
+    encoder =
+        rtc::scoped_ptr<VideoEncoder>(VideoEncoder::Create(VideoEncoder::kVp8));
+    send_config_.encoder_settings.encoder = encoder.get();
+    send_config_.encoder_settings.payload_name = "VP8";
+  } else if (params.codec == "VP9") {
+    encoder =
+        rtc::scoped_ptr<VideoEncoder>(VideoEncoder::Create(VideoEncoder::kVp9));
+    send_config_.encoder_settings.encoder = encoder.get();
+    send_config_.encoder_settings.payload_name = "VP9";
+  } else {
+    RTC_NOTREACHED() << "Codec not supported!";
+    return;
+  }
   send_config_.encoder_settings.payload_type = 124;
+
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
   send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
 
   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) {
     encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
     encoder_config_.min_transmit_bitrate_bps = 400 * 1000;
-    VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
-    vp8_settings.denoisingOn = false;
-    vp8_settings.frameDroppingOn = false;
-    vp8_settings.numberOfTemporalLayers = 2;
-    encoder_config_.encoder_specific_settings = &vp8_settings;
+    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();
+      vp9_settings.denoisingOn = false;
+      vp9_settings.frameDroppingOn = false;
+      vp9_settings.numberOfTemporalLayers = 2;
+      encoder_config_.encoder_specific_settings = &vp9_settings;
+    }
 
     stream->temporal_layer_thresholds_bps.clear();
     stream->temporal_layer_thresholds_bps.push_back(stream->target_bitrate_bps);
   }
 
   CreateMatchingReceiveConfigs();
   receive_configs_[0].renderer = &analyzer;
   receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   receive_configs_[0].rtp.rtx[kSendRtxPayloadType].ssrc = kSendRtxSsrcs[0];
   receive_configs_[0].rtp.rtx[kSendRtxPayloadType].payload_type =
@@ skipping 44 matching lines @@
 
 TEST_F(FullStackTest, ParisQcifWithoutPacketLoss) {
   FullStackTestParams paris_qcif = {"net_delay_0_0_plr_0",
                                     {"paris_qcif", 176, 144, 30},
                                     false,
                                     300000,
                                     300000,
                                     300000,
                                     36.0,
                                     0.96,
-                                    kFullStackTestDurationSecs};
+                                    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,
                                      700000,
                                      700000,
                                      700000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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,
                                      30000,
                                      500000,
                                      2000000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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,
                                      30000,
                                      2000000,
                                      2000000,
                                      0.0,
                                      0.0,
-                                     kFullStackTestDurationSecs};
+                                     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);
 }
 
-TEST_F(FullStackTest, ScreenshareSlides) {
+TEST_F(FullStackTest, ScreenshareSlidesVP8) {
   FullStackTestParams screenshare_params = {
       "screenshare_slides",
       {"screenshare_slides", 1850, 1110, 5},
+      true,
+      50000,
+      200000,
+      2000000,
+      0.0,
+      0.0,
+      kFullStackTestDurationSecs,
+      "VP8"};
+  RunTest(screenshare_params);
+}
+
+TEST_F(FullStackTest, ScreenshareSlidesVP9) {
+  FullStackTestParams screenshare_params = {
+      "screenshare_slides",
+      {"screenshare_slides", 1850, 1110, 5},
       true,
       50000,
       200000,
       2000000,
       0.0,
       0.0,
-      kFullStackTestDurationSecs};
+      kFullStackTestDurationSecs,
+      "VP9"};
   RunTest(screenshare_params);
 }
 }  // namespace webrtc