Revert of Delete VideoFrameFactory, CapturedFrame, and related code.

webrtc/media/engine/webrtcvideoframe_unittest.cc

 /*
  *  Copyright (c) 2011 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 <string.h>
 
 #include <memory>
 
 #include "webrtc/media/base/videoframe_unittest.h"
 #include "webrtc/media/engine/webrtcvideoframe.h"
 #include "webrtc/test/fake_texture_frame.h"
 
 namespace cricket {
 
 class WebRtcVideoFrameTest : public VideoFrameTest<WebRtcVideoFrame> {
  public:
   WebRtcVideoFrameTest() {}
 
+  void TestInit(int cropped_width, int cropped_height,
+                webrtc::VideoRotation frame_rotation,
+                bool apply_rotation) {
+    const int frame_width = 1920;
+    const int frame_height = 1080;
+
+    // Build the CapturedFrame.
+    CapturedFrame captured_frame;
+    captured_frame.fourcc = FOURCC_I420;
+    captured_frame.time_stamp = rtc::TimeNanos();
+    captured_frame.rotation = frame_rotation;
+    captured_frame.width = frame_width;
+    captured_frame.height = frame_height;
+    captured_frame.data_size = (frame_width * frame_height) +
+        ((frame_width + 1) / 2) * ((frame_height + 1) / 2) * 2;
+    std::unique_ptr<uint8_t[]> captured_frame_buffer(
+        new uint8_t[captured_frame.data_size]);
+    // Initialize memory to satisfy DrMemory tests.
+    memset(captured_frame_buffer.get(), 0, captured_frame.data_size);
+    captured_frame.data = captured_frame_buffer.get();
+
+    // Create the new frame from the CapturedFrame.
+    WebRtcVideoFrame frame;
+    EXPECT_TRUE(
+        frame.Init(&captured_frame, cropped_width, cropped_height,
+                   apply_rotation));
+
+    // Verify the new frame.
+    EXPECT_EQ(captured_frame.time_stamp / rtc::kNumNanosecsPerMicrosec,
+              frame.timestamp_us());
+    if (apply_rotation)
+      EXPECT_EQ(webrtc::kVideoRotation_0, frame.rotation());
+    else
+      EXPECT_EQ(frame_rotation, frame.rotation());
+    // If |apply_rotation| and the frame rotation is 90 or 270, width and
+    // height are flipped.
+    if (apply_rotation && (frame_rotation == webrtc::kVideoRotation_90
+        || frame_rotation == webrtc::kVideoRotation_270)) {
+      EXPECT_EQ(cropped_width, frame.height());
+      EXPECT_EQ(cropped_height, frame.width());
+    } else {
+      EXPECT_EQ(cropped_width, frame.width());
+      EXPECT_EQ(cropped_height, frame.height());
+    }
+  }
+
   void SetFrameRotation(WebRtcVideoFrame* frame,
                         webrtc::VideoRotation rotation) {
     frame->rotation_ = rotation;
   }
 };
 
 #define TEST_WEBRTCVIDEOFRAME(X) \
   TEST_F(WebRtcVideoFrameTest, X) { VideoFrameTest<WebRtcVideoFrame>::X(); }
 
 TEST_WEBRTCVIDEOFRAME(ConstructI420)
@@ skipping 66 matching lines @@
 // TEST_WEBRTCVIDEOFRAME(ValidateMjpgI420InvalidSize)
 // TEST_WEBRTCVIDEOFRAME(ValidateI420InvalidSize)
 
 // TODO(fbarchard): WebRtcVideoFrame does not support odd sizes.
 // Re-evaluate once WebRTC switches to libyuv
 // TEST_WEBRTCVIDEOFRAME(ConstructYuy2AllSizes)
 // TEST_WEBRTCVIDEOFRAME(ConstructARGBAllSizes)
 // TEST_WEBRTCVIDEOFRAME(ConvertToI422Buffer)
 // TEST_WEBRTCVIDEOFRAME(ConstructARGBBlackWhitePixel)
 
+// These functions test implementation-specific details.
+// Tests the Init function with different cropped size.
+TEST_F(WebRtcVideoFrameTest, InitEvenSize) {
+  TestInit(640, 360, webrtc::kVideoRotation_0, true);
+}
+
+TEST_F(WebRtcVideoFrameTest, InitOddWidth) {
+  TestInit(601, 480, webrtc::kVideoRotation_0, true);
+}
+
+TEST_F(WebRtcVideoFrameTest, InitOddHeight) {
+  TestInit(360, 765, webrtc::kVideoRotation_0, true);
+}
+
+TEST_F(WebRtcVideoFrameTest, InitOddWidthHeight) {
+  TestInit(355, 1021, webrtc::kVideoRotation_0, true);
+}
+
+TEST_F(WebRtcVideoFrameTest, InitRotated90ApplyRotation) {
+  TestInit(640, 360, webrtc::kVideoRotation_90, true);
+}
+
+TEST_F(WebRtcVideoFrameTest, InitRotated90DontApplyRotation) {
+  TestInit(640, 360, webrtc::kVideoRotation_90, false);
+}
+
 TEST_F(WebRtcVideoFrameTest, TextureInitialValues) {
   webrtc::test::FakeNativeHandle* dummy_handle =
       new webrtc::test::FakeNativeHandle();
   webrtc::NativeHandleBuffer* buffer =
       new rtc::RefCountedObject<webrtc::test::FakeNativeHandleBuffer>(
           dummy_handle, 640, 480);
 
   WebRtcVideoFrame frame(buffer, webrtc::kVideoRotation_0, 20);
   EXPECT_EQ(dummy_handle, frame.video_frame_buffer()->native_handle());
   EXPECT_EQ(640, frame.width());
@@ skipping 27 matching lines @@
   SetFrameRotation(&applied90, webrtc::kVideoRotation_270);
   WebRtcVideoFrame applied360(
       webrtc::I420Buffer::Rotate(applied90.video_frame_buffer(),
                                  applied90.rotation()),
       webrtc::kVideoRotation_0, applied90.timestamp_us());
   EXPECT_EQ(applied360.rotation(), webrtc::kVideoRotation_0);
   EXPECT_TRUE(IsEqual(applied0, applied360, 0));
 }
 
 }  // namespace cricket