text: // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #include "base/memory/scoped_ptr.h"
  #include "media/base/video_frame.h"
  #include "media/base/video_util.h"
  #include "testing/gtest/include/gtest/gtest.h"
  
  namespace media {
  
  class VideoUtilTest : public testing::Test {
   public:
    VideoUtilTest()
        : height_(0),
          y_stride_(0),
          u_stride_(0),
          v_stride_(0) {
    }
  
    virtual ~VideoUtilTest() {}
  
    void CreateSourceFrame(int width, int height,
                           int y_stride, int u_stride, int v_stride) {
      EXPECT_GE(y_stride, width);
      EXPECT_GE(u_stride, width / 2);
      EXPECT_GE(v_stride, width / 2);
  
      height_ = height;
      y_stride_ = y_stride;
      u_stride_ = u_stride;
      v_stride_ = v_stride;
  
      y_plane_.reset(new uint8[y_stride * height]);
      u_plane_.reset(new uint8[u_stride * height / 2]);
      v_plane_.reset(new uint8[v_stride * height / 2]);
    }
  
    void CreateDestinationFrame(int width, int height) {
      gfx::Size size(width, height);
      destination_frame_ =
          VideoFrame::CreateFrame(VideoFrame::YV12, size, gfx::Rect(size), size,
                                  base::TimeDelta());
    }
  
    void CopyPlanes() {
      CopyYPlane(y_plane_.get(), y_stride_, height_, destination_frame_.get());
      CopyUPlane(
          u_plane_.get(), u_stride_, height_ / 2, destination_frame_.get());
      CopyVPlane(
          v_plane_.get(), v_stride_, height_ / 2, destination_frame_.get());
    }
  
   private:
    scoped_ptr<uint8[]> y_plane_;
    scoped_ptr<uint8[]> u_plane_;
    scoped_ptr<uint8[]> v_plane_;
  
    int height_;
    int y_stride_;
    int u_stride_;
    int v_stride_;
  
    scoped_refptr<VideoFrame> destination_frame_;
  
    DISALLOW_COPY_AND_ASSIGN(VideoUtilTest);
  };
  
  TEST_F(VideoUtilTest, CopyPlane_Exact) {
    CreateSourceFrame(16, 16, 16, 8, 8);
    CreateDestinationFrame(16, 16);
    CopyPlanes();
  }
  
  TEST_F(VideoUtilTest, CopyPlane_SmallerSource) {
    CreateSourceFrame(8, 8, 8, 4, 4);
    CreateDestinationFrame(16, 16);
    CopyPlanes();
  }
  
  TEST_F(VideoUtilTest, CopyPlane_SmallerDestination) {
    CreateSourceFrame(16, 16, 16, 8, 8);
    CreateDestinationFrame(8, 8);
    CopyPlanes();
  }
  
  namespace {
  
  uint8 src6x4[] = {
    0,  1,  2,  3,  4,  5,
    6,  7,  8,  9, 10, 11,
   12, 13, 14, 15, 16, 17,
   18, 19, 20, 21, 22, 23
  };
  
  // Target images, name pattern target_rotation_flipV_flipH.
  uint8* target6x4_0_n_n = src6x4;
  
  uint8 target6x4_0_n_y[] = {
    5,  4,  3,  2,  1,  0,
   11, 10,  9,  8,  7,  6,
   17, 16, 15, 14, 13, 12,
   23, 22, 21, 20, 19, 18
  };
  
  uint8 target6x4_0_y_n[] = {
   18, 19, 20, 21, 22, 23,
   12, 13, 14, 15, 16, 17,
    6,  7,  8,  9, 10, 11,
    0,  1,  2,  3,  4,  5
  };
  
  uint8 target6x4_0_y_y[] = {
   23, 22, 21, 20, 19, 18,
   17, 16, 15, 14, 13, 12,
   11, 10,  9,  8,  7,  6,
    5,  4,  3,  2,  1,  0
  };
  
  uint8 target6x4_90_n_n[] = {
   255, 19, 13,  7,  1, 255,
   255, 20, 14,  8,  2, 255,
   255, 21, 15,  9,  3, 255,
   255, 22, 16, 10,  4, 255
  };
  
  uint8 target6x4_90_n_y[] = {
   255,  1,  7, 13, 19, 255,
   255,  2,  8, 14, 20, 255,
   255,  3,  9, 15, 21, 255,
   255,  4, 10, 16, 22, 255
  };
  
  uint8 target6x4_90_y_n[] = {
   255, 22, 16, 10,  4, 255,
   255, 21, 15,  9,  3, 255,
   255, 20, 14,  8,  2, 255,
   255, 19, 13,  7,  1, 255
  };
  
  uint8 target6x4_90_y_y[] = {
   255,  4, 10, 16, 22, 255,
   255,  3,  9, 15, 21, 255,
   255,  2,  8, 14, 20, 255,
   255,  1,  7, 13, 19, 255
  };
  
  uint8* target6x4_180_n_n = target6x4_0_y_y;
  uint8* target6x4_180_n_y = target6x4_0_y_n;
  uint8* target6x4_180_y_n = target6x4_0_n_y;
  uint8* target6x4_180_y_y = target6x4_0_n_n;
  
  uint8* target6x4_270_n_n = target6x4_90_y_y;
  uint8* target6x4_270_n_y = target6x4_90_y_n;
  uint8* target6x4_270_y_n = target6x4_90_n_y;
  uint8* target6x4_270_y_y = target6x4_90_n_n;
  
  uint8 src4x6[] = {
    0,  1,  2,  3,
    4,  5,  6,  7,
    8,  9, 10, 11,
   12, 13, 14, 15,
   16, 17, 18, 19,
   20, 21, 22, 23
  };
  
  uint8* target4x6_0_n_n = src4x6;
  
  uint8 target4x6_0_n_y[] = {
    3,  2,  1,  0,
    7,  6,  5,  4,
   11, 10,  9,  8,
   15, 14, 13, 12,
   19, 18, 17, 16,
   23, 22, 21, 20
  };
  
  uint8 target4x6_0_y_n[] = {
   20, 21, 22, 23,
   16, 17, 18, 19,
   12, 13, 14, 15,
    8,  9, 10, 11,
    4,  5,  6,  7,
    0,  1,  2,  3
  };
  
  uint8 target4x6_0_y_y[] = {
   23, 22, 21, 20,
   19, 18, 17, 16,
   15, 14, 13, 12,
   11, 10,  9,  8,
    7,  6,  5,  4,
    3,  2,  1,  0
  };
  
  uint8 target4x6_90_n_n[] = {
   255, 255, 255, 255,
    16,  12,   8,   4,
    17,  13,   9,   5,
    18,  14,  10,   6,
    19,  15,  11,   7,
   255, 255, 255, 255
  };
  
  uint8 target4x6_90_n_y[] = {
   255, 255, 255, 255,
     4,   8,  12,  16,
     5,   9,  13,  17,
     6,  10,  14,  18,
     7,  11,  15,  19,
   255, 255, 255, 255
  };
  
  uint8 target4x6_90_y_n[] = {
   255, 255, 255, 255,
    19,  15,  11,   7,
    18,  14,  10,   6,
    17,  13,   9,   5,
    16,  12,   8,   4,
   255, 255, 255, 255
  };
  
  uint8 target4x6_90_y_y[] = {
   255, 255, 255, 255,
     7,  11,  15,  19,
     6,  10,  14,  18,
     5,   9,  13,  17,
     4,   8,  12,  16,
   255, 255, 255, 255
  };
  
  uint8* target4x6_180_n_n = target4x6_0_y_y;
  uint8* target4x6_180_n_y = target4x6_0_y_n;
  uint8* target4x6_180_y_n = target4x6_0_n_y;
  uint8* target4x6_180_y_y = target4x6_0_n_n;
  
  uint8* target4x6_270_n_n = target4x6_90_y_y;
  uint8* target4x6_270_n_y = target4x6_90_y_n;
  uint8* target4x6_270_y_n = target4x6_90_n_y;
  uint8* target4x6_270_y_y = target4x6_90_n_n;
  
  struct VideoRotationTestData {
    uint8* src;
    uint8* target;
    int width;
    int height;
    int rotation;
    bool flip_vert;
    bool flip_horiz;
  };
  
  const VideoRotationTestData kVideoRotationTestData[] = {
    { src6x4, target6x4_0_n_n, 6, 4, 0, false, false },
    { src6x4, target6x4_0_n_y, 6, 4, 0, false, true },
    { src6x4, target6x4_0_y_n, 6, 4, 0, true, false },
    { src6x4, target6x4_0_y_y, 6, 4, 0, true, true },
  
    { src6x4, target6x4_90_n_n, 6, 4, 90, false, false },
    { src6x4, target6x4_90_n_y, 6, 4, 90, false, true },
    { src6x4, target6x4_90_y_n, 6, 4, 90, true, false },
    { src6x4, target6x4_90_y_y, 6, 4, 90, true, true },
  
    { src6x4, target6x4_180_n_n, 6, 4, 180, false, false },
    { src6x4, target6x4_180_n_y, 6, 4, 180, false, true },
    { src6x4, target6x4_180_y_n, 6, 4, 180, true, false },
    { src6x4, target6x4_180_y_y, 6, 4, 180, true, true },
  
    { src6x4, target6x4_270_n_n, 6, 4, 270, false, false },
    { src6x4, target6x4_270_n_y, 6, 4, 270, false, true },
    { src6x4, target6x4_270_y_n, 6, 4, 270, true, false },
    { src6x4, target6x4_270_y_y, 6, 4, 270, true, true },
  
    { src4x6, target4x6_0_n_n, 4, 6, 0, false, false },
    { src4x6, target4x6_0_n_y, 4, 6, 0, false, true },
    { src4x6, target4x6_0_y_n, 4, 6, 0, true, false },
    { src4x6, target4x6_0_y_y, 4, 6, 0, true, true },
  
    { src4x6, target4x6_90_n_n, 4, 6, 90, false, false },
    { src4x6, target4x6_90_n_y, 4, 6, 90, false, true },
    { src4x6, target4x6_90_y_n, 4, 6, 90, true, false },
    { src4x6, target4x6_90_y_y, 4, 6, 90, true, true },
  
    { src4x6, target4x6_180_n_n, 4, 6, 180, false, false },
    { src4x6, target4x6_180_n_y, 4, 6, 180, false, true },
    { src4x6, target4x6_180_y_n, 4, 6, 180, true, false },
    { src4x6, target4x6_180_y_y, 4, 6, 180, true, true },
  
    { src4x6, target4x6_270_n_n, 4, 6, 270, false, false },
    { src4x6, target4x6_270_n_y, 4, 6, 270, false, true },
    { src4x6, target4x6_270_y_n, 4, 6, 270, true, false },
    { src4x6, target4x6_270_y_y, 4, 6, 270, true, true }
  };
  
  }  // namespace
  
  class VideoUtilRotationTest
      : public testing::TestWithParam<VideoRotationTestData> {
   public:
    VideoUtilRotationTest() {
      dest_.reset(new uint8[GetParam().width * GetParam().height]);
    }
  
    virtual ~VideoUtilRotationTest() {}
  
    uint8* dest_plane() { return dest_.get(); }
  
   private:
    scoped_ptr<uint8[]> dest_;
  
    DISALLOW_COPY_AND_ASSIGN(VideoUtilRotationTest);
  };
  
  TEST_P(VideoUtilRotationTest, Rotate) {
    int rotation = GetParam().rotation;
    EXPECT_TRUE((rotation >= 0) && (rotation < 360) && (rotation % 90 == 0));
  
    int size = GetParam().width * GetParam().height;
    uint8* dest = dest_plane();
    memset(dest, 255, size);
  
    RotatePlaneByPixels(GetParam().src, dest, GetParam().width,
                        GetParam().height, rotation,
                        GetParam().flip_vert, GetParam().flip_horiz);
  
    EXPECT_EQ(memcmp(dest, GetParam().target, size), 0);
  }
  
  INSTANTIATE_TEST_CASE_P(, VideoUtilRotationTest,
                          testing::ValuesIn(kVideoRotationTestData));
  
  TEST_F(VideoUtilTest, ComputeLetterboxRegion) {
    EXPECT_EQ(gfx::Rect(167, 0, 666, 500),
              ComputeLetterboxRegion(gfx::Rect(0, 0, 1000, 500),
                                     gfx::Size(640, 480)));
    EXPECT_EQ(gfx::Rect(0, 312, 500, 375),
              ComputeLetterboxRegion(gfx::Rect(0, 0, 500, 1000),
                                     gfx::Size(640, 480)));
    EXPECT_EQ(gfx::Rect(56, 0, 888, 500),
              ComputeLetterboxRegion(gfx::Rect(0, 0, 1000, 500),
                                     gfx::Size(1920, 1080)));
    EXPECT_EQ(gfx::Rect(0, 12, 100, 75),
              ComputeLetterboxRegion(gfx::Rect(0, 0, 100, 100),
                                     gfx::Size(400, 300)));
    EXPECT_EQ(gfx::Rect(0, 250000000, 2000000000, 1500000000),
              ComputeLetterboxRegion(gfx::Rect(0, 0, 2000000000, 2000000000),
                                     gfx::Size(40000, 30000)));
  }
  
  TEST_F(VideoUtilTest, LetterboxYUV) {
    int width = 40;
    int height = 30;
    gfx::Size size(width, height);
    scoped_refptr<VideoFrame> frame(
        VideoFrame::CreateFrame(VideoFrame::YV12, size, gfx::Rect(size), size,
                                base::TimeDelta()));
  
    for (int left_margin = 0; left_margin <= 10; left_margin += 10) {
      for (int right_margin = 0; right_margin <= 10; right_margin += 10) {
        for (int top_margin = 0; top_margin <= 10; top_margin += 10) {
          for (int bottom_margin = 0; bottom_margin <= 10; bottom_margin += 10) {
            gfx::Rect view_area(left_margin, top_margin,
                                width - left_margin - right_margin,
                                height - top_margin - bottom_margin);
            FillYUV(frame.get(), 0x1, 0x2, 0x3);
            LetterboxYUV(frame.get(), view_area);
            for (int x = 0; x < width; x++) {
              for (int y = 0; y < height; y++) {
                bool inside = x >= view_area.x() &&
                    x < view_area.x() + view_area.width() &&
                    y >= view_area.y() &&
                    y < view_area.y() + view_area.height();
                EXPECT_EQ(frame->data(VideoFrame::kYPlane)[
                    y * frame->stride(VideoFrame::kYPlane) + x],
                          inside ? 0x01 : 0x00);
                EXPECT_EQ(frame->data(VideoFrame::kUPlane)[
                    (y / 2) * frame->stride(VideoFrame::kUPlane) + (x / 2)],
                          inside ? 0x02 : 0x80);
                EXPECT_EQ(frame->data(VideoFrame::kVPlane)[
                    (y / 2) * frame->stride(VideoFrame::kVPlane) + (x / 2)],
                          inside ? 0x03 : 0x80);
              }
            }
          }
        }
      }
    }
  }
  
  }  // namespace media
  