Make cricket::VideoCapturer implement VideoSourceInterface

webrtc/media/base/videocapturer_unittest.cc

 /*
  *  Copyright (c) 2008 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 17 matching lines @@
 const int kMinHdHeight = 720;
 const uint32_t kTimeout = 5000U;
 
 }  // namespace
 
 class VideoCapturerTest
     : public sigslot::has_slots<>,
       public testing::Test {
  public:
   VideoCapturerTest()
-      : capture_state_(cricket::CS_STOPPED),
-        num_state_changes_(0),
-        video_frames_received_(0),
-        expects_rotation_applied_(true) {
-    capturer_.SignalVideoFrame.connect(this, &VideoCapturerTest::OnVideoFrame);
+      : capture_state_(cricket::CS_STOPPED), num_state_changes_(0) {
     capturer_.SignalStateChange.connect(this,
                                         &VideoCapturerTest::OnStateChange);
-  }
-
-  void set_expected_compensation(bool compensation) {
-    expects_rotation_applied_ = compensation;
+    capturer_.AddOrUpdateSink(&renderer_, rtc::VideoWants());
   }
 
  protected:
-  void OnVideoFrame(cricket::VideoCapturer*, const cricket::VideoFrame* frame) {
-    ++video_frames_received_;
-    if (expects_rotation_applied_) {
-      EXPECT_EQ(webrtc::kVideoRotation_0, frame->GetRotation());
-    } else {
-      EXPECT_EQ(capturer_.GetRotation(), frame->GetRotation());
-    }
-    renderer_.RenderFrame(frame);
-  }
   void OnStateChange(cricket::VideoCapturer*,
                      cricket::CaptureState capture_state) {
     capture_state_ = capture_state;
     ++num_state_changes_;
   }
   cricket::CaptureState capture_state() { return capture_state_; }
   int num_state_changes() { return num_state_changes_; }
-  int video_frames_received() const {
-    return video_frames_received_;
-  }
 
   cricket::FakeVideoCapturer capturer_;
   cricket::CaptureState capture_state_;
   int num_state_changes_;
-  int video_frames_received_;
   cricket::FakeVideoRenderer renderer_;
   bool expects_rotation_applied_;
 };
 
 TEST_F(VideoCapturerTest, CaptureState) {
   EXPECT_TRUE(capturer_.enable_video_adapter());
   EXPECT_EQ(cricket::CS_RUNNING, capturer_.Start(cricket::VideoFormat(
       640,
       480,
       cricket::VideoFormat::FpsToInterval(30),
@@ skipping 56 matching lines @@
   EXPECT_EQ(1, num_state_changes());
 }
 
 TEST_F(VideoCapturerTest, CameraOffOnMute) {
   EXPECT_EQ(cricket::CS_RUNNING, capturer_.Start(cricket::VideoFormat(
       640,
       480,
       cricket::VideoFormat::FpsToInterval(30),
       cricket::FOURCC_I420)));
   EXPECT_TRUE(capturer_.IsRunning());
-  EXPECT_EQ(0, video_frames_received());
+  EXPECT_EQ(0, renderer_.num_rendered_frames());
   EXPECT_TRUE(capturer_.CaptureFrame());
-  EXPECT_EQ(1, video_frames_received());
+  EXPECT_EQ(1, renderer_.num_rendered_frames());
   EXPECT_FALSE(capturer_.IsMuted());
 
   // Mute the camera and expect black output frame.
   capturer_.MuteToBlackThenPause(true);
   EXPECT_TRUE(capturer_.IsMuted());
   for (int i = 0; i < 31; ++i) {
     EXPECT_TRUE(capturer_.CaptureFrame());
     EXPECT_TRUE(renderer_.black_frame());
   }
-  EXPECT_EQ(32, video_frames_received());
+  EXPECT_EQ(32, renderer_.num_rendered_frames());
   EXPECT_EQ_WAIT(cricket::CS_PAUSED,
                  capturer_.capture_state(), kTimeout);
 
   // Verify that the camera is off.
   EXPECT_FALSE(capturer_.CaptureFrame());
-  EXPECT_EQ(32, video_frames_received());
+  EXPECT_EQ(32, renderer_.num_rendered_frames());
 
   // Unmute the camera and expect non-black output frame.
   capturer_.MuteToBlackThenPause(false);
   EXPECT_FALSE(capturer_.IsMuted());
   EXPECT_EQ_WAIT(cricket::CS_RUNNING,
                  capturer_.capture_state(), kTimeout);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_FALSE(renderer_.black_frame());
-  EXPECT_EQ(33, video_frames_received());
+  EXPECT_EQ(33, renderer_.num_rendered_frames());
 }
 
 TEST_F(VideoCapturerTest, ScreencastScaledOddWidth) {
   capturer_.SetScreencast(true);
 
   int kWidth = 1281;
   int kHeight = 720;
 
   std::vector<cricket::VideoFormat> formats;
   formats.push_back(cricket::VideoFormat(kWidth, kHeight,
       cricket::VideoFormat::FpsToInterval(5), cricket::FOURCC_ARGB));
   capturer_.ResetSupportedFormats(formats);
 
   EXPECT_EQ(cricket::CS_RUNNING, capturer_.Start(cricket::VideoFormat(
       kWidth,
       kHeight,
       cricket::VideoFormat::FpsToInterval(30),
       cricket::FOURCC_ARGB)));
   EXPECT_TRUE(capturer_.IsRunning());
   EXPECT_EQ(0, renderer_.num_rendered_frames());
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(1, renderer_.num_rendered_frames());
   EXPECT_EQ(kWidth, renderer_.width());
   EXPECT_EQ(kHeight, renderer_.height());
 }
 
-TEST_F(VideoCapturerTest, TestRotationPending) {
+TEST_F(VideoCapturerTest, TestRotationAppliedBySource) {
   int kWidth = 800;
   int kHeight = 400;
   int frame_count = 0;
 
   std::vector<cricket::VideoFormat> formats;
   formats.push_back(cricket::VideoFormat(kWidth, kHeight,
                                          cricket::VideoFormat::FpsToInterval(5),
                                          cricket::FOURCC_I420));
 
   capturer_.ResetSupportedFormats(formats);
+
   // capturer_ should compensate rotation as default.
   capturer_.UpdateAspectRatio(400, 200);
 
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer_.Start(cricket::VideoFormat(
                 kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
                 cricket::FOURCC_I420)));
   EXPECT_TRUE(capturer_.IsRunning());
   EXPECT_EQ(0, renderer_.num_rendered_frames());
 
   // If the frame's rotation is compensated anywhere in the pipeline based on
   // the rotation information, the renderer should be given the right dimension
   // such that the frame could be rendered.
 
   capturer_.SetRotation(webrtc::kVideoRotation_90);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
   // Swapped width and height
   EXPECT_EQ(kWidth, renderer_.height());
   EXPECT_EQ(kHeight, renderer_.width());
+  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
 
   capturer_.SetRotation(webrtc::kVideoRotation_270);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
   // Swapped width and height
   EXPECT_EQ(kWidth, renderer_.height());
   EXPECT_EQ(kHeight, renderer_.width());
+  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
 
   capturer_.SetRotation(webrtc::kVideoRotation_180);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
   // Back to normal width and height
   EXPECT_EQ(kWidth, renderer_.width());
   EXPECT_EQ(kHeight, renderer_.height());
+  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
 }
 
-TEST_F(VideoCapturerTest, TestRotationApplied) {
+TEST_F(VideoCapturerTest, TestRotationAppliedBySink) {
   int kWidth = 800;
   int kHeight = 400;
 
   std::vector<cricket::VideoFormat> formats;
   formats.push_back(cricket::VideoFormat(kWidth, kHeight,
                                          cricket::VideoFormat::FpsToInterval(5),
                                          cricket::FOURCC_I420));
 
   capturer_.ResetSupportedFormats(formats);
+  rtc::VideoWants wants;
   // capturer_ should not compensate rotation.
-  capturer_.SetApplyRotation(false);
+  wants.rotation_applied = false;
+  capturer_.AddOrUpdateSink(&renderer_, wants);
+
   capturer_.UpdateAspectRatio(400, 200);
-  set_expected_compensation(false);
 
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer_.Start(cricket::VideoFormat(
                 kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
                 cricket::FOURCC_I420)));
   EXPECT_TRUE(capturer_.IsRunning());
   EXPECT_EQ(0, renderer_.num_rendered_frames());
 
   // If the frame's rotation is compensated anywhere in the pipeline, the frame
   // won't have its original dimension out from capturer. Since the renderer
   // here has the same dimension as the capturer, it will skip that frame as the
   // resolution won't match anymore.
 
   int frame_count = 0;
   capturer_.SetRotation(webrtc::kVideoRotation_0);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
+  EXPECT_EQ(capturer_.GetRotation(), renderer_.rotation());
 
   capturer_.SetRotation(webrtc::kVideoRotation_90);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
+  EXPECT_EQ(capturer_.GetRotation(), renderer_.rotation());
 
   capturer_.SetRotation(webrtc::kVideoRotation_180);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
+  EXPECT_EQ(capturer_.GetRotation(), renderer_.rotation());
 
   capturer_.SetRotation(webrtc::kVideoRotation_270);
   EXPECT_TRUE(capturer_.CaptureFrame());
   EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
+  EXPECT_EQ(capturer_.GetRotation(), renderer_.rotation());
+}
+
+TEST_F(VideoCapturerTest, TestRotationAppliedBySourceWhenDifferentWants) {
+  int kWidth = 800;
+  int kHeight = 400;
+
+  std::vector<cricket::VideoFormat> formats;
+  formats.push_back(cricket::VideoFormat(kWidth, kHeight,
+                                         cricket::VideoFormat::FpsToInterval(5),
+                                         cricket::FOURCC_I420));
+
+  capturer_.ResetSupportedFormats(formats);
+  rtc::VideoWants wants;
+  // capturer_ should not compensate rotation.
+  wants.rotation_applied = false;
+  capturer_.AddOrUpdateSink(&renderer_, wants);
+
+  capturer_.UpdateAspectRatio(400, 200);
+
+  EXPECT_EQ(cricket::CS_RUNNING,
+            capturer_.Start(cricket::VideoFormat(
+                kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
+                cricket::FOURCC_I420)));
+  EXPECT_TRUE(capturer_.IsRunning());
+  EXPECT_EQ(0, renderer_.num_rendered_frames());
+
+  int frame_count = 0;
+  capturer_.SetRotation(webrtc::kVideoRotation_90);
+  EXPECT_TRUE(capturer_.CaptureFrame());
+  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
+  EXPECT_EQ(capturer_.GetRotation(), renderer_.rotation());
+
+  // Add another sink that wants frames to be rotated.
+  cricket::FakeVideoRenderer renderer2;
+  wants.rotation_applied = true;
+  capturer_.AddOrUpdateSink(&renderer2, wants);
+
+  EXPECT_TRUE(capturer_.CaptureFrame());
+  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
+  EXPECT_EQ(1, renderer2.num_rendered_frames());
+  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
+  EXPECT_EQ(webrtc::kVideoRotation_0, renderer2.rotation());
 }
 
 TEST_F(VideoCapturerTest, ScreencastScaledSuperLarge) {
   capturer_.SetScreencast(true);
 
   const int kMaxWidth = 4096;
   const int kMaxHeight = 3072;
   int kWidth = kMaxWidth + 4;
   int kHeight = kMaxHeight + 4;
 
@@ skipping 402 matching lines @@
     EXPECT_EQ(required_formats[i].width, best.width);
     EXPECT_EQ(required_formats[i].height, best.height);
   }
 
   // Expect 16x9 for 16x9 request.
   EXPECT_TRUE(capturer_.GetBestCaptureFormat(required_formats[2], &best));
   EXPECT_EQ(640, best.width);
   EXPECT_EQ(360, best.height);
 }
 
-// If HAVE_WEBRTC_VIDEO is not defined the video capturer will not be able to
-// provide OnVideoFrame-callbacks since they require cricket::CapturedFrame to
-// be decoded as a cricket::VideoFrame (i.e. an I420 frame). This functionality
-// only exist if HAVE_WEBRTC_VIDEO is defined below. I420 frames are also a
-// requirement for the VideoProcessors so they will not be called either.
-#if defined(HAVE_WEBRTC_VIDEO)
-TEST_F(VideoCapturerTest, VideoFrame) {
-  EXPECT_EQ(cricket::CS_RUNNING, capturer_.Start(cricket::VideoFormat(
-      640,
-      480,
-      cricket::VideoFormat::FpsToInterval(30),
-      cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_.IsRunning());
-  EXPECT_EQ(0, video_frames_received());
-  EXPECT_TRUE(capturer_.CaptureFrame());
-  EXPECT_EQ(1, video_frames_received());
-}
-#endif  // HAVE_WEBRTC_VIDEO
-
 bool HdFormatInList(const std::vector<cricket::VideoFormat>& formats) {
   for (std::vector<cricket::VideoFormat>::const_iterator found =
            formats.begin(); found != formats.end(); ++found) {
     if (found->height >= kMinHdHeight) {
       return true;
     }
   }
   return false;
 }
 
@@ skipping 44 matching lines @@
   capturer_.set_enable_camera_list(true);
   capturer_.ConstrainSupportedFormats(vga_format);
   EXPECT_EQ(2u, capturer_.GetSupportedFormats()->size());
   // To make sure it's not just the camera list being broken, add in VGA and
   // try again. This time, only the VGA format should be there.
   supported_formats.push_back(vga_format);
   capturer_.ResetSupportedFormats(supported_formats);
   ASSERT_EQ(1u, capturer_.GetSupportedFormats()->size());
   EXPECT_EQ(vga_format.height, capturer_.GetSupportedFormats()->at(0).height);
 }