Let ViEEncoder express resolution requests as Sinkwants

webrtc/video/video_send_stream_tests.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 <algorithm>  // max
@@ skipping 39 matching lines @@
 VideoFrame CreateVideoFrame(int width, int height, uint8_t data);
 
 class VideoSendStreamTest : public test::CallTest {
  protected:
   void TestNackRetransmission(uint32_t retransmit_ssrc,
                               uint8_t retransmit_payload_type);
   void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
 
   void TestVp9NonFlexMode(uint8_t num_temporal_layers,
                           uint8_t num_spatial_layers);
+
+  void TestRequestSourceRotateVideo(bool support_orientation_ext);
 };
 
 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
   CreateVideoStreams();
   video_send_stream_->Start();
   video_send_stream_->Start();
@@ skipping 178 matching lines @@
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
     }
 
     test::FakeEncoder encoder_;
   } test;
 
   RunBaseTest(&test);
 }
 
+TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
+  class VideoRotationObserver : public test::SendTest {
+   public:
+    VideoRotationObserver() : SendTest(kDefaultTimeoutMs) {
+      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
+          kRtpExtensionVideoRotation, test::kVideoRotationExtensionId));
+    }
+
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      RTPHeader header;
+      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+      EXPECT_TRUE(header.extension.hasVideoRotation);
+      EXPECT_EQ(kVideoRotation_90, header.extension.videoRotation);
+      observation_complete_.Set();
+      return SEND_PACKET;
+    }
+
+    void ModifyVideoConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      send_config->rtp.extensions.clear();
+      send_config->rtp.extensions.push_back(RtpExtension(
+          RtpExtension::kVideoRotationUri, test::kVideoRotationExtensionId));
+    }
+
+    void OnFrameGeneratorCapturerCreated(
+        test::FrameGeneratorCapturer* frame_generator_capturer) override {
+      frame_generator_capturer->SetFakeRotation(kVideoRotation_90);
+    }
+
+    void PerformTest() override {
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
+    }
+  } test;
+
+  RunBaseTest(&test);
+}
+
 class FakeReceiveStatistics : public NullReceiveStatistics {
  public:
   FakeReceiveStatistics(uint32_t send_ssrc,
                         uint32_t last_sequence_number,
                         uint32_t cumulative_lost,
                         uint8_t fraction_lost)
       : lossy_stats_(new LossyStatistician(last_sequence_number,
                                            cumulative_lost,
                                            fraction_lost)) {
     stats_map_[send_ssrc] = lossy_stats_.get();
@@ skipping 1381 matching lines @@
       handle1, width, height, 1, 1, kVideoRotation_0));
   input_frames.push_back(test::FakeNativeHandle::CreateFrame(
       handle2, width, height, 2, 2, kVideoRotation_0));
   input_frames.push_back(CreateVideoFrame(width, height, 3));
   input_frames.push_back(CreateVideoFrame(width, height, 4));
   input_frames.push_back(test::FakeNativeHandle::CreateFrame(
       handle3, width, height, 5, 5, kVideoRotation_0));
 
   video_send_stream_->Start();
   test::FrameForwarder forwarder;
-  video_send_stream_->SetSource(&forwarder);
+  video_send_stream_->SetSource(
+      &forwarder, VideoSendStream::DegradationPreference::kBalanced);
   for (size_t i = 0; i < input_frames.size(); i++) {
     forwarder.IncomingCapturedFrame(input_frames[i]);
     // Wait until the output frame is received before sending the next input
     // frame. Or the previous input frame may be replaced without delivering.
     observer.WaitOutputFrame();
   }
   video_send_stream_->Stop();
-  video_send_stream_->SetSource(nullptr);
+  video_send_stream_->SetSource(
+      nullptr, VideoSendStream::DegradationPreference::kBalanced);
 
   // Test if the input and output frames are the same. render_time_ms and
   // timestamp are not compared because capturer sets those values.
   ExpectEqualFramesVector(input_frames, observer.output_frames());
 
   DestroyStreams();
 }
 
 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
                              const std::vector<VideoFrame>& frames2) {
@@ skipping 1194 matching lines @@
         EXPECT_GT(vp9_header.num_ref_pics, 0u);
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
+void VideoSendStreamTest::TestRequestSourceRotateVideo(
+    bool support_orientation_ext) {
+  CreateSenderCall(Call::Config(&event_log_));
+
+  test::NullTransport transport;
+  CreateSendConfig(1, 0, &transport);
+  video_send_config_.rtp.extensions.clear();
+  if (support_orientation_ext) {
+    video_send_config_.rtp.extensions.push_back(
+        RtpExtension(RtpExtension::kVideoRotationUri, 1));
+  }
+
+  CreateVideoStreams();
+  test::FrameForwarder forwarder;
+  video_send_stream_->SetSource(
+      &forwarder, VideoSendStream::DegradationPreference::kBalanced);
+
+  EXPECT_TRUE(forwarder.sink_wants().rotation_applied !=
+              support_orientation_ext);
+
+  DestroyStreams();
+}
+
+TEST_F(VideoSendStreamTest,
+       RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
+  TestRequestSourceRotateVideo(false);
+}
+
+TEST_F(VideoSendStreamTest,
+       DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
+  TestRequestSourceRotateVideo(true);
+}
+
 }  // namespace webrtc