Add unittest for I420Buffer::Rotate.

webrtc/common_video/i420_video_frame_unittest.cc

 /*
  *  Copyright (c) 2012 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 29 matching lines @@
       buffer->MutableDataV()[x + y * chroma_width] =
           255 * y / (chroma_height - 1);
     }
   }
   return buffer;
 }
 
 // The offsets and sizes describe the rectangle extracted from the
 // original (gradient) frame, in relative coordinates where the
 // original frame correspond to the unit square, 0.0 <= x, y < 1.0.
-void CheckCrop(webrtc::VideoFrameBuffer* frame,
+void CheckCrop(const webrtc::VideoFrameBuffer& frame,
                double offset_x,
                double offset_y,
                double rel_width,
                double rel_height) {
-  int width = frame->width();
-  int height = frame->height();
+  int width = frame.width();
+  int height = frame.height();
   // Check that pixel values in the corners match the gradient used
   // for initialization.
   for (int i = 0; i < 2; i++) {
     for (int j = 0; j < 2; j++) {
       // Pixel coordinates of the corner.
       int x = i * (width - 1);
       int y = j * (height - 1);
       // Relative coordinates, range 0.0 - 1.0 correspond to the
       // size of the uncropped input frame.
       double orig_x = offset_x + i * rel_width;
       double orig_y = offset_y + j * rel_height;
 
-      EXPECT_NEAR(frame->DataY()[x + y * frame->StrideY()] / 256.0,
+      EXPECT_NEAR(frame.DataY()[x + y * frame.StrideY()] / 256.0,
                   (orig_x + orig_y) / 2, 0.02);
-      EXPECT_NEAR(frame->DataU()[x / 2 + (y / 2) * frame->StrideU()] / 256.0,
+      EXPECT_NEAR(frame.DataU()[x / 2 + (y / 2) * frame.StrideU()] / 256.0,
                   orig_x, 0.02);
-      EXPECT_NEAR(frame->DataV()[x / 2 + (y / 2) * frame->StrideV()] / 256.0,
+      EXPECT_NEAR(frame.DataV()[x / 2 + (y / 2) * frame.StrideV()] / 256.0,
                   orig_y, 0.02);
     }
   }
 }
 
+void CheckRotate(int width, int height, webrtc::VideoRotation rotation,
+                 const webrtc::VideoFrameBuffer& rotated) {
+  int rotated_width = width;
+  int rotated_height = height;
+
+  if (rotation == kVideoRotation_90 || rotation == kVideoRotation_270) {
+    std::swap(rotated_width, rotated_height);
+  }
+  EXPECT_EQ(rotated.width(), rotated_width);

[perkj_webrtc, 2016/10/09 18:13:44]

nit, expect orders. Put the expectation as the first argument and what you check
in the second. And yes, its the opposite for EXPECT_GT etc.

[nisse-webrtc, 2016/10/18 09:34:21]

Done.

+  EXPECT_EQ(rotated.height(), rotated_height);
+
+  // Clock-wise order (with 0,0 at top-left)
+  const struct { int x; int y; } corners[] = {
+    { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 }
+  };
+  // Corresponding corner colors of the frame produced by CreateGradient.
+  const struct { int y; int u; int v; } colors[] = {
+    {0, 0, 0}, { 127, 255, 0}, { 255, 255, 255 }, {127, 0, 255}
+  };
+  int corner_offset = static_cast<int>(rotation) / 90;
+
+  for (int i = 0; i < 4; i++) {
+    int j = (i + corner_offset) % 4;
+    int x = corners[j].x * (rotated_width - 1);
+    int y = corners[j].y * (rotated_height - 1);
+    EXPECT_EQ(colors[i].y, rotated.DataY()[x + y * rotated.StrideY()]);
+    EXPECT_EQ(colors[i].u,
+              rotated.DataU()[(x / 2) + (y / 2) * rotated.StrideU()]);
+    EXPECT_EQ(colors[i].v,
+              rotated.DataV()[(x / 2) + (y / 2) * rotated.StrideV()]);
+  }
+}
+
 }  // namespace
 
 TEST(TestVideoFrame, InitialValues) {
   VideoFrame frame;
   EXPECT_TRUE(frame.IsZeroSize());
   EXPECT_EQ(kVideoRotation_0, frame.rotation());
 }
 
 TEST(TestVideoFrame, CopiesInitialFrameWithoutCrashing) {
   VideoFrame frame;
@@ skipping 164 matching lines @@
 }
 
 TEST(TestI420FrameBuffer, Scale) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(200, 100);
 
   // Pure scaling, no cropping.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(150, 75));
 
   scaled_buffer->ScaleFrom(buf);
-  CheckCrop(scaled_buffer, 0.0, 0.0, 1.0, 1.0);
+  CheckCrop(*scaled_buffer, 0.0, 0.0, 1.0, 1.0);
 }
 
 TEST(TestI420FrameBuffer, CropXCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(200, 100);
 
   // Pure center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
   scaled_buffer->CropAndScaleFrom(buf, 50, 0, 100, 100);
-  CheckCrop(scaled_buffer, 0.25, 0.0, 0.5, 1.0);
+  CheckCrop(*scaled_buffer, 0.25, 0.0, 0.5, 1.0);
 }
 
 TEST(TestI420FrameBuffer, CropXNotCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(200, 100);
 
   // Non-center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
   scaled_buffer->CropAndScaleFrom(buf, 25, 0, 100, 100);
-  CheckCrop(scaled_buffer, 0.125, 0.0, 0.5, 1.0);
+  CheckCrop(*scaled_buffer, 0.125, 0.0, 0.5, 1.0);
 }
 
 TEST(TestI420FrameBuffer, CropYCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(100, 200);
 
   // Pure center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
   scaled_buffer->CropAndScaleFrom(buf, 0, 50, 100, 100);
-  CheckCrop(scaled_buffer, 0.0, 0.25, 1.0, 0.5);
+  CheckCrop(*scaled_buffer, 0.0, 0.25, 1.0, 0.5);
 }
 
 TEST(TestI420FrameBuffer, CropYNotCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(100, 200);
 
   // Non-center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
   scaled_buffer->CropAndScaleFrom(buf, 0, 25, 100, 100);
-  CheckCrop(scaled_buffer, 0.0, 0.125, 1.0, 0.5);
+  CheckCrop(*scaled_buffer, 0.0, 0.125, 1.0, 0.5);
 }
 
 TEST(TestI420FrameBuffer, CropAndScale16x9) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(640, 480);
 
   // Center crop to 640 x 360 (16/9 aspect), then scale down by 2.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(320, 180));
 
   scaled_buffer->CropAndScaleFrom(buf);
-  CheckCrop(scaled_buffer, 0.0, 0.125, 1.0, 0.75);
+  CheckCrop(*scaled_buffer, 0.0, 0.125, 1.0, 0.75);
+}
+
+TEST(TestI420FrameBuffer, Rotate_0) {
+  rtc::scoped_refptr<VideoFrameBuffer> buffer = CreateGradient(640, 480);
+  rtc::scoped_refptr<VideoFrameBuffer> rotated_buffer =
+      I420Buffer::Rotate(buffer, kVideoRotation_0);
+  CheckRotate(640, 480, kVideoRotation_0, *rotated_buffer);
+}
+
+TEST(TestI420FrameBuffer, Rotate_90) {
+  rtc::scoped_refptr<VideoFrameBuffer> buffer = CreateGradient(640, 480);
+  rtc::scoped_refptr<VideoFrameBuffer> rotated_buffer =
+      I420Buffer::Rotate(buffer, kVideoRotation_90);
+  CheckRotate(640, 480, kVideoRotation_90, *rotated_buffer);
+}
+TEST(TestI420FrameBuffer, Rotate_180) {
+  rtc::scoped_refptr<VideoFrameBuffer> buffer = CreateGradient(640, 480);
+  rtc::scoped_refptr<VideoFrameBuffer> rotated_buffer =
+      I420Buffer::Rotate(buffer, kVideoRotation_180);
+  CheckRotate(640, 480, kVideoRotation_180, *rotated_buffer);
+}
+TEST(TestI420FrameBuffer, Rotate_270) {
+  rtc::scoped_refptr<VideoFrameBuffer> buffer = CreateGradient(640, 480);
+  rtc::scoped_refptr<VideoFrameBuffer> rotated_buffer =
+      I420Buffer::Rotate(buffer, kVideoRotation_270);
+  CheckRotate(640, 480, kVideoRotation_270, *rotated_buffer);
 }
 
 }  // namespace webrtc