New flag is_screencast in VideoOptions.

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.
  */
 
@@ skipping 1454 matching lines @@
   cricket::VideoCodec codec = kVp8Codec360p;
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
   parameters.options.screencast_min_bitrate_kbps =
       rtc::Optional<int>(kScreenshareMinBitrateKbps);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
-  capturer.SetScreencast(false);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   cricket::VideoFormat capture_format_hd =
       capturer.GetSupportedFormats()->front();
   EXPECT_EQ(1280, capture_format_hd.width);
   EXPECT_EQ(720, capture_format_hd.height);
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
 
   EXPECT_TRUE(channel_->SetSend(true));
 
   EXPECT_TRUE(capturer.CaptureFrame());
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
 
   EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
 
   // Verify non-screencast settings.
   webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig();
   EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
             encoder_config.content_type);
   EXPECT_EQ(codec.width, encoder_config.streams.front().width);
   EXPECT_EQ(codec.height, encoder_config.streams.front().height);
   EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
       << "Non-screenshare shouldn't use min-transmit bitrate.";
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, nullptr));
   // Removing a capturer triggers a black frame to be sent.
   EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
-  capturer.SetScreencast(true);
-  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
-  EXPECT_TRUE(capturer.CaptureFrame());
+
+  FakeVideoCapturer screencast_capturer(true);
+  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &screencast_capturer));
+  EXPECT_EQ(cricket::CS_RUNNING, screencast_capturer.Start(capture_format_hd));
+  parameters.options.is_screencast = rtc::Optional<bool>(true);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  EXPECT_TRUE(screencast_capturer.CaptureFrame());
+  // Send stream not recreated after option change.
+  ASSERT_EQ(send_stream, fake_call_->GetVideoSendStreams().front());
   EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
 
   // Verify screencast settings.
   encoder_config = send_stream->GetEncoderConfig();
   EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
             encoder_config.content_type);
   EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
             encoder_config.min_transmit_bitrate_bps);
 
   EXPECT_EQ(capture_format_hd.width, encoder_config.streams.front().width);
   EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
   EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
+TEST_F(WebRtcVideoChannel2Test, NoRecreateStreamForScreencast) {
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));

[nisse-webrtc, 2016/03/01 13:24:40]

Maybe this test is somewhat redundant, behavior is also tested by the
UsesCorrectSettingsForScreencast test.

[nisse-webrtc, 2016/03/02 08:09:51]

Something is broken, and the tests too...

First, VideoSourceInitialize is intended to make sure that the is_screencast
option always is present, with value taken from capturer->IsScreencast().

But I added logging to OnLoadUpdate, and at that point, is_screencast is always
unset when running the rtc_media_unittests. (The tests are not using
VideoSource, I guess, so we have a somewhat poor test coverage of the
propagatino logic. So testcases must be updated to explicitly set the flag using
SetSendParameters or SetVideoSend or so). Are there any higher level "end2end"
tests which test cpu adaptation? I tried peerconnection_unittests and
rtc_pc_unitttests, but neither hit the OnLoadUpdate method.

But despite these two bugs in OnLoadUpdate and in the testcode, the
WebRtcVideoChannel2Test.DoesNotAdaptOnOveruseWhenScreensharing test succeeds.
It's logs an unwanted resolution change,

[000:008] (webrtcvideoengine2.cc:1917): OnLoadUpdate 0
[000:008] (webrtcvideoengine2.cc:1925): OnLoadUpdate: unset
[000:008] (videoadapter.cc:559): VAdapt CPU Request: down Steps: 1 Changed: true
To: 960x540

but the checks

    EXPECT_EQ(codec.width, send_stream->GetLastWidth());
    EXPECT_EQ(codec.height, send_stream->GetLastHeight());

are still true, GetLastWidth and GetLastHeight return 1280x720. So it seems the
new resolution isn't applied. Some more debugging needed.

+  ASSERT_TRUE(
+      channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
+  EXPECT_TRUE(channel_->SetSend(true));
+
+  cricket::FakeVideoCapturer capturer;
+  EXPECT_TRUE(channel_->SetCapturer(kSsrc, &capturer));
+  EXPECT_EQ(cricket::CS_RUNNING,
+            capturer.Start(capturer.GetSupportedFormats()->front()));
+  EXPECT_TRUE(capturer.CaptureFrame());
+
+  ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
+  FakeVideoSendStream* stream1 = fake_call_->GetVideoSendStreams().front();
+  webrtc::VideoEncoderConfig encoder_config = stream1->GetEncoderConfig();
+  EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
+            encoder_config.content_type);
+
+  EXPECT_EQ(1, stream1->GetNumberOfSwappedFrames());
+
+  /* Switch to screencast source. We expect a reconfigure of the
+   * encoder, but no change of the send stream. */
+  struct VideoOptions video_options;
+  video_options.is_screencast = rtc::Optional<bool>(true);
+  channel_->SetVideoSend(kSsrc, true, &video_options);
+
+  EXPECT_TRUE(capturer.CaptureFrame());
+  ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams());
+  FakeVideoSendStream* stream2 = fake_call_->GetVideoSendStreams().front();
+  EXPECT_EQ(stream1, stream2);
+  EXPECT_EQ(2, stream2->GetNumberOfSwappedFrames());
+
+  encoder_config = stream2->GetEncoderConfig();
+  EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
+            encoder_config.content_type);
+
+  EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
+}

[pbos-webrtc, 2016/03/01 16:11:36]

Should we check switching from screencast? I think that might be a bug in the
current implementation.

+
 TEST_F(WebRtcVideoChannel2Test,
        ConferenceModeScreencastConfiguresTemporalLayer) {
   static const int kConferenceScreencastTemporalBitrateBps =
       ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
   send_parameters_.conference_mode = true;
+  send_parameters_.options.is_screencast = rtc::Optional<bool>(true);
   channel_->SetSendParameters(send_parameters_);
 
   AddSendStream();
 
-  cricket::FakeVideoCapturer capturer;
-  capturer.SetScreencast(true);
+  cricket::FakeVideoCapturer capturer(true);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   cricket::VideoFormat capture_format_hd =
       capturer.GetSupportedFormats()->front();
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
 
   EXPECT_TRUE(channel_->SetSend(true));
 
   EXPECT_TRUE(capturer.CaptureFrame());
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
@@ skipping 49 matching lines @@
 TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec720p);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   // Single-stream settings should apply with RTX as well (verifies that we
   // check number of regular SSRCs and not StreamParams::ssrcs which contains
   // both RTX and regular SSRCs).
   FakeVideoSendStream* stream = SetUpSimulcast(false, true);
 
-  cricket::FakeVideoCapturer capturer;
-  capturer.SetScreencast(false);
+  cricket::FakeVideoCapturer capturer(false);
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
 
   EXPECT_TRUE(capturer.CaptureFrame());
 
   webrtc::VideoCodecVP8 vp8_settings;
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_TRUE(vp8_settings.denoisingOn)
@@ skipping 19 matching lines @@
   channel_->SetSend(true);
   EXPECT_TRUE(capturer.CaptureFrame());
 
   EXPECT_EQ(3, stream->GetVideoStreams().size());
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   // Autmatic resize off when using simulcast.
   EXPECT_FALSE(vp8_settings.automaticResizeOn);
   EXPECT_TRUE(vp8_settings.frameDroppingOn);
 
   // In screen-share mode, denoising is forced off and simulcast disabled.
-  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
-  capturer.SetScreencast(true);
-  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
-  EXPECT_TRUE(capturer.CaptureFrame());
-  stream = SetDenoisingOption(parameters, &capturer, false);
+  FakeVideoCapturer screencast_capturer(true);
+  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &screencast_capturer));
+  EXPECT_EQ(cricket::CS_RUNNING, screencast_capturer.Start(
+      screencast_capturer.GetSupportedFormats()->front()));
+  parameters.options.is_screencast = rtc::Optional<bool>(true);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+
+  stream = SetDenoisingOption(parameters, &screencast_capturer, false);
 
   EXPECT_EQ(1, stream->GetVideoStreams().size());
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_FALSE(vp8_settings.denoisingOn);
   // Resizing and frame dropping always off for screen sharing.
   EXPECT_FALSE(vp8_settings.automaticResizeOn);
   EXPECT_FALSE(vp8_settings.frameDroppingOn);
 
   stream = SetDenoisingOption(parameters, &capturer, true);
 
@@ skipping 28 matching lines @@
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
 };
 
 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp9Codec);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = SetUpSimulcast(false, false);
 
-  cricket::FakeVideoCapturer capturer;
-  capturer.SetScreencast(false);
+  cricket::FakeVideoCapturer capturer(false);
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
 
   EXPECT_TRUE(capturer.CaptureFrame());
 
   webrtc::VideoCodecVP9 vp9_settings;
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn)
       << "VP9 denoising should be off by default.";
 
   stream = SetDenoisingOption(parameters, &capturer, false);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
   // Frame dropping always on for real time video.
   EXPECT_TRUE(vp9_settings.frameDroppingOn);
 
   stream = SetDenoisingOption(parameters, &capturer, true);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_TRUE(vp9_settings.denoisingOn);
   EXPECT_TRUE(vp9_settings.frameDroppingOn);
 
   // In screen-share mode, denoising is forced off.
-  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, nullptr));
-  capturer.SetScreencast(true);
-  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
+  FakeVideoCapturer screencast_capturer(true);
+  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &screencast_capturer));
+  EXPECT_EQ(cricket::CS_RUNNING, screencast_capturer.Start(
+      screencast_capturer.GetSupportedFormats()->front()));
+  parameters.options.is_screencast = rtc::Optional<bool>(true);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
-  EXPECT_TRUE(capturer.CaptureFrame());
-  stream = SetDenoisingOption(parameters, &capturer, false);
+  stream = SetDenoisingOption(parameters, &screencast_capturer, false);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
   // Frame dropping always off for screen sharing.
   EXPECT_FALSE(vp9_settings.frameDroppingOn);
 
   stream = SetDenoisingOption(parameters, &capturer, false);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
@@ skipping 20 matching lines @@
   parameters.codecs.push_back(codec);
 
   MediaConfig media_config = MediaConfig();
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
-  capturer.SetScreencast(false);
   ASSERT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   ASSERT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   ASSERT_TRUE(channel_->SetSend(true));
 
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
   webrtc::LoadObserver* overuse_callback =
       send_stream->GetConfig().overuse_callback;
   ASSERT_TRUE(overuse_callback != NULL);
@@ skipping 50 matching lines @@
   if (!enable_overuse) {
     media_config.video.enable_cpu_overuse_detection = false;
   }
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
 
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
-  cricket::FakeVideoCapturer capturer;
-  capturer.SetScreencast(is_screenshare);
+  cricket::FakeVideoCapturer capturer(is_screenshare);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
 
   EXPECT_TRUE(channel_->SetSend(true));
 
   // Trigger overuse.
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
   webrtc::LoadObserver* overuse_callback =
@@ skipping 1329 matching lines @@
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   cricket::VideoCodec codec(kVp8Codec270p);
   codec.width += 1;
   codec.height += 1;
   VerifySimulcastSettings(codec, 2, 2);
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO