Cleanup the VideoAdapter

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 1994 matching lines @@
   EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
   EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
 
   // Trigger overuse again.
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
   EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
   EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
   EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
   EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
 
+  // Trigger overuse again. This should not decrease the resolution since we
+  // should only adapt the resolution down max two steps.
+  overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
+  EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
+  EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth());
+  EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight());
+
   // Change input resolution.
   EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
-  EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames());
   EXPECT_EQ(1284 / 2, send_stream->GetLastWidth());
   EXPECT_EQ(724 / 2, send_stream->GetLastHeight());
 
   // Trigger underuse which should go back up in resolution.
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
   EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
-  EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
   EXPECT_EQ(1284 * 3 / 4, send_stream->GetLastWidth());
   EXPECT_EQ(724 * 3 / 4, send_stream->GetLastHeight());
 
   // Trigger underuse which should go back up in resolution.
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
   EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
-  EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(7, send_stream->GetNumberOfSwappedFrames());
   EXPECT_EQ(1284, send_stream->GetLastWidth());
   EXPECT_EQ(724, send_stream->GetLastHeight());
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
+TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndSwitchToScreenShare) {

[pbos-webrtc, 2016/04/05 10:22:32]

PreviousAdaptationDoesNotApplyToScreenshare?

[perkj_webrtc, 2016/04/05 11:44:45]

Done.

+  cricket::VideoCodec codec = kVp8Codec720p;
+  cricket::VideoSendParameters parameters;
+  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;
+  ASSERT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
+  ASSERT_EQ(cricket::CS_RUNNING,
+            capturer.Start(capturer.GetSupportedFormats()->front()));
+  ASSERT_TRUE(channel_->SetSend(true));
+  cricket::VideoOptions camera_options;
+  channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options);
+
+  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);
+
+  EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
+  EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(1280, send_stream->GetLastWidth());
+  EXPECT_EQ(720, send_stream->GetLastHeight());
+
+  // Trigger overuse.
+  overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
+  EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
+  EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
+  EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
+
+  // Switch to screen share. Expect no CPU adaptation.
+  cricket::FakeVideoCapturer screen_share(true);
+  ASSERT_EQ(cricket::CS_RUNNING,
+            screen_share.Start(screen_share.GetSupportedFormats()->front()));
+  ASSERT_TRUE(channel_->SetCapturer(last_ssrc_, &screen_share));
+  cricket::VideoOptions screenshare_options;
+  screenshare_options.is_screencast = rtc::Optional<bool>(true);
+  channel_->SetVideoSend(last_ssrc_, true /* enable */, &screenshare_options);
+  EXPECT_TRUE(screen_share.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
+  EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(1284, send_stream->GetLastWidth());
+  EXPECT_EQ(724, send_stream->GetLastHeight());
+
+  // Switch back to the normal capturer. Expect the frame to be CPU adapted.
+  ASSERT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
+  channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options);
+  EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
+  EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
+  EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
+  EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
+
+  EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
+}
+
 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
                                                 bool is_screenshare) {
   cricket::VideoCodec codec = kVp8Codec720p;
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
 
   MediaConfig media_config = MediaConfig();
   if (!enable_overuse) {
     media_config.video.enable_cpu_overuse_detection = false;
   }
@@ skipping 704 matching lines @@
       fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
   ASSERT_TRUE(overuse_callback != NULL);
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
 
   // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
   EXPECT_TRUE(video_capturer_vga.CaptureFrame());
   cricket::VideoMediaInfo info;
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
   EXPECT_EQ(1, info.senders[0].adapt_changes);
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
-            info.senders[0].adapt_reason);
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
 
   // Trigger upgrade and verify that we adapt back up to VGA.
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
   EXPECT_TRUE(video_capturer_vga.CaptureFrame());
   info.Clear();
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
   EXPECT_EQ(2, info.senders[0].adapt_changes);
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
             info.senders[0].adapt_reason);
 
   // No capturer (no adapter). Adapt changes from old adapter should be kept.
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
   info.Clear();
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
   EXPECT_EQ(2, info.senders[0].adapt_changes);
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
             info.senders[0].adapt_reason);
 
   // Set new capturer, capture format HD.
   cricket::FakeVideoCapturer video_capturer_hd;
   cricket::VideoFormat capture_format_hd = (*formats)[0];
   EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd));
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_hd));
   EXPECT_TRUE(video_capturer_hd.CaptureFrame());
 
   // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2.
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
   EXPECT_TRUE(video_capturer_hd.CaptureFrame());
   info.Clear();
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
   EXPECT_EQ(3, info.senders[0].adapt_changes);
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
-            info.senders[0].adapt_reason);
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
 
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationAndBandwidthStats) {
   AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
 
   // Capture format VGA.
   cricket::FakeVideoCapturer video_capturer_vga;
   const std::vector<cricket::VideoFormat>* formats =
@@ skipping 14 matching lines @@
   // Trigger overuse -> adapt CPU.
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   webrtc::LoadObserver* overuse_callback =
       fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
   ASSERT_TRUE(overuse_callback != NULL);
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
   EXPECT_TRUE(video_capturer_vga.CaptureFrame());
   cricket::VideoMediaInfo info;
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU,
-            info.senders[0].adapt_reason);
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason);
 
   // Set bandwidth limitation stats for the stream -> adapt CPU + BW.
   webrtc::VideoSendStream::Stats stats;
   stats.bw_limited_resolution = true;
   fake_call_->GetVideoSendStreams().front()->SetStats(stats);
   info.Clear();
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_CPU +
-            CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH,
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU |
+                WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
             info.senders[0].adapt_reason);
 
   // Trigger upgrade -> adapt BW.
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse);
   EXPECT_TRUE(video_capturer_vga.CaptureFrame());
   info.Clear();
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH,
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
             info.senders[0].adapt_reason);
 
   // Reset bandwidth limitation state -> adapt NONE.
   stats.bw_limited_resolution = false;
   fake_call_->GetVideoSendStreams().front()->SetStats(stats);
   info.Clear();
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_NONE,
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE,
             info.senders[0].adapt_reason);
 
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        GetStatsTranslatesBandwidthLimitedResolutionCorrectly) {
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoSendStream::Stats stats;
   stats.bw_limited_resolution = true;
   stream->SetStats(stats);
 
   cricket::VideoMediaInfo info;
   EXPECT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1U, info.senders.size());
-  EXPECT_EQ(CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH,
+  EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH,
             info.senders[0].adapt_reason);
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoSendStream::Stats stats;
   stats.substreams[17].rtcp_packet_type_counts.fir_packets = 2;
   stats.substreams[17].rtcp_packet_type_counts.nack_packets = 3;
   stats.substreams[17].rtcp_packet_type_counts.pli_packets = 4;
@@ skipping 601 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