Add DesktopFrame rotation functions

webrtc/modules/desktop_capture/desktop_frame_rotator_unittest.cc

+/*
+ *  Copyright (c) 2016 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 "webrtc/modules/desktop_capture/desktop_frame_rotator.h"
+
+#include "webrtc/modules/desktop_capture/desktop_frame.h"
+#include "webrtc/modules/desktop_capture/desktop_region.h"
+#include "webrtc/modules/desktop_capture/rgba_color.h"
+#include "webrtc/modules/desktop_capture/test_utils.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+
+// A DesktopFrame implementation which stores data in external int array.
+class ArrayDesktopFrame : public DesktopFrame {
+ public:
+  ArrayDesktopFrame(DesktopSize size, uint32_t* data);
+  ~ArrayDesktopFrame() override;
+};
+
+ArrayDesktopFrame::ArrayDesktopFrame(DesktopSize size, uint32_t* data)
+    : DesktopFrame(size,
+                   size.width() * kBytesPerPixel,
+                   reinterpret_cast<uint8_t*>(data),
+                   nullptr) {}
+
+ArrayDesktopFrame::~ArrayDesktopFrame() = default;
+
+}  // namespace
+
+TEST(DesktopFrameRotatorTest, CopyRect3x4) {
+  // A DesktopFrame of 4-pixel width by 3-pixel height.
+  static uint32_t frame_pixels[] = {
+      0, 1,  2,  3,  //
+      4, 5,  6,  7,  //
+      8, 9, 10, 11,  //
+  };
+  ArrayDesktopFrame frame(DesktopSize(4, 3), frame_pixels);
+
+  {
+    BasicDesktopFrame target(DesktopSize(4, 3));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_0, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(frame, target));
+
+    BasicDesktopFrame target2(DesktopSize(4, 3));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                  Rotation::CLOCK_WISE_0, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(frame, target2));
+  }
+
+  // After Rotating clock-wise 90 degree
+  {
+    static uint32_t expected_pixels[] = {
+         8, 4, 0,  //
+         9, 5, 1,  //
+        10, 6, 2,  //
+        11, 7, 3,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 4), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 4));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_90, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 4));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_90, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 180 degree
+  {
+    static uint32_t expected_pixels[] = {
+        11, 10, 9, 8,  //
+         7,  6, 5, 4,  //
+         3,  2, 1, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(4, 3), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(4, 3));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_180, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(4, 3));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_180, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 270 degree
+  {
+    static uint32_t expected_pixels[] = {
+        3, 7, 11,  //
+        2, 6, 10,  //
+        1, 5,  9,  //
+        0, 4,  8,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 4), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 4));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_270, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 4));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_270, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+}
+
+TEST(DesktopFrameRotatorTest, CopyRect3x5) {
+  // A DesktopFrame of 5-pixel width by 3-pixel height.
+  static uint32_t frame_pixels[] = {
+       0,  1,  2,  3,  4,  //
+       5,  6,  7,  8,  9,  //
+      10, 11, 12, 13, 14,  //
+  };
+  ArrayDesktopFrame frame(DesktopSize(5, 3), frame_pixels);
+
+  {
+    BasicDesktopFrame target(DesktopSize(5, 3));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_0, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, frame));
+
+    BasicDesktopFrame target2(DesktopSize(5, 3));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                  Rotation::CLOCK_WISE_0, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, frame));
+  }
+
+  // After Rotating clock-wise 90 degree
+  {
+    static uint32_t expected_pixels[] = {
+        10, 5, 0,  //
+        11, 6, 1,  //
+        12, 7, 2,  //
+        13, 8, 3,  //
+        14, 9, 4,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 5), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 5));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_90, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 5));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_90, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 180 degree
+  {
+    static uint32_t expected_pixels[] {
+        14, 13, 12, 11, 10,  //
+         9,  8,  7,  6,  5,  //
+         4,  3,  2,  1,  0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(5, 3), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(5, 3));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_180, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(5, 3));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_180, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 270 degree
+  {
+    static uint32_t expected_pixels[] = {
+        4, 9, 14,  //
+        3, 8, 13,  //
+        2, 7, 12,  //
+        1, 6, 11,  //
+        0, 5, 10,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 5), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 5));
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeSize(frame.size()),
+                                    Rotation::CLOCK_WISE_270, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 5));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_270, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+}
+
+TEST(DesktopFrameRotatorTest, PartialCopyRect3x5) {
+  // A DesktopFrame of 5-pixel width by 3-pixel height.
+  static uint32_t frame_pixels[] = {
+       0,  1,  2,  3,  4,  //
+       5,  6,  7,  8,  9,  //
+      10, 11, 12, 13, 14,  //
+  };
+  ArrayDesktopFrame frame(DesktopSize(5, 3), frame_pixels);
+
+  {
+    static uint32_t expected_pixels[] = {
+        0, 0, 0, 0, 0,  //
+        0, 6, 7, 8, 0,  //
+        0, 0, 0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(5, 3), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(5, 3));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 1),
+                                    Rotation::CLOCK_WISE_0, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(5, 3));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 1),
+                                  Rotation::CLOCK_WISE_0, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  {
+    static uint32_t expected_pixels[] = {
+        0, 1, 2, 3, 0,  //
+        0, 6, 7, 8, 0,  //
+        0, 0, 0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(5, 3), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(5, 3));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 0, 3, 2),
+                                    Rotation::CLOCK_WISE_0, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(5, 3));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(1, 0, 3, 2),
+                                  Rotation::CLOCK_WISE_0, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 90 degree
+  {
+    static uint32_t expected_pixels[] = {
+        0, 0, 0,  //
+        0, 6, 0,  //
+        0, 7, 0,  //
+        0, 8, 0,  //
+        0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 5), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 5));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 1),
+                                    Rotation::CLOCK_WISE_90, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 5));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 1, 3),
+                                  Rotation::CLOCK_WISE_90, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  {
+    static uint32_t expected_pixels[] = {
+         0, 0, 0,  //
+        11, 6, 0,  //
+        12, 7, 0,  //
+        13, 8, 0,  //
+         0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 5), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 5));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 2),
+                                    Rotation::CLOCK_WISE_90, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 5));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(0, 1, 2, 3),
+                                  Rotation::CLOCK_WISE_90, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 180 degree
+  {
+    static uint32_t expected_pixels[] = {
+        0, 0, 0, 0, 0,  //
+        0, 8, 7, 6, 0,  //
+        0, 0, 0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(5, 3), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(5, 3));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 1),
+                                    Rotation::CLOCK_WISE_180, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(5, 3));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 1),
+                                  Rotation::CLOCK_WISE_180, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  {
+    static uint32_t expected_pixels[] = {
+        0, 13, 12, 11, 0,  //
+        0,  8,  7,  6, 0,  //
+        0,  0,  0,  0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(5, 3), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(5, 3));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 2),
+                                    Rotation::CLOCK_WISE_180, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(5, 3));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(1, 0, 3, 2),
+                                  Rotation::CLOCK_WISE_180, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  // After Rotating clock-wise 270 degree
+  {
+    static uint32_t expected_pixels[] = {
+        0, 0, 0,  //
+        0, 8, 0,  //
+        0, 7, 0,  //
+        0, 6, 0,  //
+        0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 5), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 5));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 3, 1),
+                                    Rotation::CLOCK_WISE_270, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 5));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(1, 1, 1, 3),
+                                  Rotation::CLOCK_WISE_270, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+
+  {
+    static uint32_t expected_pixels[] = {
+        0, 0, 0,  //
+        3, 8, 0,  //
+        2, 7, 0,  //
+        1, 6, 0,  //
+        0, 0, 0,  //
+    };
+    ArrayDesktopFrame expected(DesktopSize(3, 5), expected_pixels);
+
+    BasicDesktopFrame target(DesktopSize(3, 5));
+    ClearDesktopFrame(&target);
+    ASSERT_TRUE(CopyUnrotatedRectTo(frame, DesktopRect::MakeXYWH(1, 0, 3, 2),
+                                    Rotation::CLOCK_WISE_270, &target));
+    ASSERT_TRUE(DesktopFrameDataEquals(target, expected));
+
+    BasicDesktopFrame target2(DesktopSize(3, 5));
+    ClearDesktopFrame(&target2);
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeXYWH(0, 1, 2, 3),
+                                  Rotation::CLOCK_WISE_270, &target2));
+    ASSERT_TRUE(DesktopFrameDataEquals(target2, expected));
+  }
+}
+
+// On a typical machine (Intel(R) Xeon(R) E5-1650 v3 @ 3.50GHz, with O2
+// optimization, the following case uses ~1.4s to finish. It means entirely
+// rotating one 2048 x 1536 frame, which is a large enough number to cover most
+// of desktop computer users, uses around 14ms.
+TEST(DesktopFrameRotatorTest, DISABLED_PerformanceTest) {
+  BasicDesktopFrame frame(DesktopSize(2048, 1536));
+  BasicDesktopFrame target(DesktopSize(1536, 2048));
+  BasicDesktopFrame target2(DesktopSize(2048, 1536));
+  for (int i = 0; i < 100; i++) {
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target.size()),
+                                  Rotation::CLOCK_WISE_90, &target));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target.size()),
+                                  Rotation::CLOCK_WISE_270, &target));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_0, &target2));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_180, &target2));
+  }
+}
+
+// On a typical machine (Intel(R) Xeon(R) E5-1650 v3 @ 3.50GHz, with O2
+// optimization, the following case uses ~6.7s to finish. It means entirely
+// rotating one 4096 x 3072 frame uses around 67ms.
+TEST(DesktopFrameRotatorTest, DISABLED_PerformanceTestOnLargeScreen) {
+  BasicDesktopFrame frame(DesktopSize(4096, 3072));
+  BasicDesktopFrame target(DesktopSize(3072, 4096));
+  BasicDesktopFrame target2(DesktopSize(4096, 3072));
+  for (int i = 0; i < 100; i++) {
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target.size()),
+                                  Rotation::CLOCK_WISE_90, &target));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target.size()),
+                                  Rotation::CLOCK_WISE_270, &target));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_0, &target2));
+    ASSERT_TRUE(CopyRotatedRectTo(frame, DesktopRect::MakeSize(target2.size()),
+                                  Rotation::CLOCK_WISE_180, &target2));
+  }
+}
+
+}  // namespace webrtc