Add experimental simulcast screen content mode

webrtc/media/engine/webrtcvideoengine2_unittest.cc

 /*
  *  Copyright (c) 2004 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 <algorithm>
 #include <list>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/media/base/videoengine_unittest.h"
+#include "webrtc/media/engine/constants.h"
 #include "webrtc/media/engine/fakewebrtccall.h"
 #include "webrtc/media/engine/fakewebrtcvideoengine.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/webrtcvideoengine2.h"
 #include "webrtc/media/engine/webrtcvoiceengine.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/video_encoder.h"
 
 using webrtc::RtpExtension;
 
@@ skipping 3885 matching lines @@
   TestReceiverLocalSsrcConfiguration(false);
 }
 
 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) {
   TestReceiverLocalSsrcConfiguration(true);
 }
 
 class WebRtcVideoChannel2SimulcastTest : public testing::Test {
  public:
   WebRtcVideoChannel2SimulcastTest()
-      : fake_call_(webrtc::Call::Config(&event_log_)) {}
+      : fake_call_(webrtc::Call::Config(&event_log_)), last_ssrc_(0) {}
 
   void SetUp() override {
     engine_.Init();
     channel_.reset(
         engine_.CreateChannel(&fake_call_, MediaConfig(), VideoOptions()));
     channel_->OnReadyToSend(true);
     last_ssrc_ = 123;
   }
 
  protected:
   void VerifySimulcastSettings(const VideoCodec& codec,
                                int capture_width,
                                int capture_height,
                                size_t num_configured_streams,
-                               size_t expected_num_streams) {
+                               size_t expected_num_streams,
+                               bool screenshare,
+                               bool conference_mode) {
     cricket::VideoSendParameters parameters;
+    VideoOptions options;
     parameters.codecs.push_back(codec);
+    parameters.conference_mode = conference_mode;
+    if (screenshare) {
+      options.is_screencast = rtc::Optional<bool>(screenshare);
+    }
     ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
     std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
     RTC_DCHECK(num_configured_streams <= ssrcs.size());
     ssrcs.resize(num_configured_streams);
 
     FakeVideoSendStream* stream =
         AddSendStream(CreateSimStreamParams("cname", ssrcs));
     // Send a full-size frame to trigger a stream reconfiguration to use all
     // expected simulcast layers.
     cricket::FakeVideoCapturer capturer;
     EXPECT_TRUE(
-        channel_->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
+        channel_->SetVideoSend(ssrcs.front(), true, &options, &capturer));
     EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
                                        capture_width, capture_height,
                                        cricket::VideoFormat::FpsToInterval(30),
                                        cricket::FOURCC_I420)));
     channel_->SetSend(true);
     EXPECT_TRUE(capturer.CaptureFrame());
 
     std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
     ASSERT_EQ(expected_num_streams, video_streams.size());
 
-    std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
-        num_configured_streams, capture_width, capture_height, 0, kDefaultQpMax,
-        kDefaultVideoMaxFramerate);
+    std::vector<webrtc::VideoStream> expected_streams;
+    if (conference_mode) {
+      expected_streams = GetSimulcastConfig(
+          num_configured_streams, capture_width, capture_height, 0,
+          kDefaultQpMax, kDefaultVideoMaxFramerate, screenshare);
+    } else {
+      webrtc::VideoStream stream;
+      stream.width = capture_width;
+      stream.height = capture_height;
+      stream.max_framerate = kDefaultVideoMaxFramerate;
+      stream.min_bitrate_bps = cricket::kMinVideoBitrateKbps * 1000;
+      int max_bitrate_kbps;
+      if (capture_width * capture_height <= 320 * 240) {
+        max_bitrate_kbps = 600;
+      } else if (capture_width * capture_height <= 640 * 480) {
+        max_bitrate_kbps = 1700;
+      } else if (capture_width * capture_height <= 960 * 540) {
+        max_bitrate_kbps = 2000;
+      } else {
+        max_bitrate_kbps = 2500;
+      }
+      stream.target_bitrate_bps = stream.max_bitrate_bps =
+          max_bitrate_kbps * 1000;
+      stream.max_qp = kDefaultQpMax;
+      expected_streams.push_back(stream);
+    }
 
     ASSERT_EQ(expected_streams.size(), video_streams.size());
 
     size_t num_streams = video_streams.size();
     int total_max_bitrate_bps = 0;
     for (size_t i = 0; i < num_streams; ++i) {
       EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
       EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
 
       EXPECT_GT(video_streams[i].max_framerate, 0);
       EXPECT_EQ(expected_streams[i].max_framerate,
                 video_streams[i].max_framerate);
 
       EXPECT_GT(video_streams[i].min_bitrate_bps, 0);
       EXPECT_EQ(expected_streams[i].min_bitrate_bps,
                 video_streams[i].min_bitrate_bps);
 
       EXPECT_GT(video_streams[i].target_bitrate_bps, 0);
       EXPECT_EQ(expected_streams[i].target_bitrate_bps,
                 video_streams[i].target_bitrate_bps);
 
       EXPECT_GT(video_streams[i].max_bitrate_bps, 0);
       EXPECT_EQ(expected_streams[i].max_bitrate_bps,
                 video_streams[i].max_bitrate_bps);
 
       EXPECT_GT(video_streams[i].max_qp, 0);
       EXPECT_EQ(expected_streams[i].max_qp, video_streams[i].max_qp);
 
-      EXPECT_FALSE(expected_streams[i].temporal_layer_thresholds_bps.empty());
+      EXPECT_EQ(!conference_mode,
+                expected_streams[i].temporal_layer_thresholds_bps.empty());
       EXPECT_EQ(expected_streams[i].temporal_layer_thresholds_bps,
                 video_streams[i].temporal_layer_thresholds_bps);
 
       if (i == num_streams - 1) {
         total_max_bitrate_bps += video_streams[i].max_bitrate_bps;
       } else {
         total_max_bitrate_bps += video_streams[i].target_bitrate_bps;
       }
     }
 
@@ skipping 33 matching lines @@
   }
 
   webrtc::RtcEventLogNullImpl event_log_;
   FakeCall fake_call_;
   WebRtcVideoEngine2 engine_;
   std::unique_ptr<VideoMediaChannel> channel_;
   uint32_t last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
-  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2);
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2, false,
+                          true);
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
-  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3);
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3, false,
+                          true);
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
-  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2);
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2, false,
+                          true);
 }
+
+TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsForScreenshare) {
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 1, true,
+                          false);
+}
+
+TEST_F(WebRtcVideoChannel2SimulcastTest,
+       SetSendCodecsForConferenceModeScreenshare) {
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 1, true,
+                          true);
+}
+
+TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsForSimulcastScreenshare) {
+  webrtc::test::ScopedFieldTrials override_field_trials_(
+      "WebRTC-SimulcastScreenshare/Enabled/");
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 2, true,
+                          true);
+}
+
 }  // namespace cricket