// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "base/message_loop/message_loop.h"
#include "media/base/video_frame.h"
#include "media/base/video_util.h"
#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/skia/include/core/SkBitmapDevice.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "media/filters/skcanvas_video_renderer.h"
// Helper for filling a |canvas| with a solid |color|.
void FillCanvas(SkCanvas* canvas, SkColor color) {
- const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(true);
- bitmap.lockPixels();
- bitmap.eraseColor(color);
- bitmap.unlockPixels();
+ canvas->clear(color);
}
// Helper for returning the color of a solid |canvas|.
SkColor GetColorAt(SkCanvas* canvas, int x, int y) {
- const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(false);
- bitmap.lockPixels();
- SkColor c = bitmap.getColor(x, y);
- bitmap.unlockPixels();
- return c;
+ SkBitmap bitmap;
+ if (!bitmap.tryAllocN32Pixels(1, 1))
+ return 0;
+ if (!canvas->readPixels(&bitmap, x, y))
+ return 0;
+ return bitmap.getColor(0, 0);
}
SkColor GetColor(SkCanvas* canvas) {
};
SkCanvasVideoRendererTest();
- virtual ~SkCanvasVideoRendererTest();
+ ~SkCanvasVideoRendererTest() override;
// Paints to |canvas| using |renderer_| without any frame data.
void PaintWithoutFrame(SkCanvas* canvas);
// Paints the |video_frame| to the |canvas| using |renderer_|, setting the
// color of |video_frame| to |color| first.
- void Paint(VideoFrame* video_frame, SkCanvas* canvas, Color color);
+ void Paint(const scoped_refptr<VideoFrame>& video_frame,
+ SkCanvas* canvas,
+ Color color);
+ void PaintRotated(const scoped_refptr<VideoFrame>& video_frame,
+ SkCanvas* canvas,
+ const gfx::RectF& dest_rect,
+ Color color,
+ SkXfermode::Mode mode,
+ VideoRotation video_rotation);
+
+ void Copy(const scoped_refptr<VideoFrame>& video_frame, SkCanvas* canvas);
// Getters for various frame sizes.
- VideoFrame* natural_frame() { return natural_frame_.get(); }
- VideoFrame* larger_frame() { return larger_frame_.get(); }
- VideoFrame* smaller_frame() { return smaller_frame_.get(); }
- VideoFrame* cropped_frame() { return cropped_frame_.get(); }
+ scoped_refptr<VideoFrame> natural_frame() { return natural_frame_; }
+ scoped_refptr<VideoFrame> larger_frame() { return larger_frame_; }
+ scoped_refptr<VideoFrame> smaller_frame() { return smaller_frame_; }
+ scoped_refptr<VideoFrame> cropped_frame() { return cropped_frame_; }
- // Getters for canvases that trigger the various painting paths.
- SkCanvas* fast_path_canvas() { return &fast_path_canvas_; }
- SkCanvas* slow_path_canvas() { return &slow_path_canvas_; }
+ // Standard canvas.
+ SkCanvas* target_canvas() { return &target_canvas_; }
private:
SkCanvasVideoRenderer renderer_;
scoped_refptr<VideoFrame> smaller_frame_;
scoped_refptr<VideoFrame> cropped_frame_;
- SkBitmapDevice fast_path_device_;
- SkCanvas fast_path_canvas_;
- SkBitmapDevice slow_path_device_;
- SkCanvas slow_path_canvas_;
+ SkCanvas target_canvas_;
+ base::MessageLoop message_loop_;
DISALLOW_COPY_AND_ASSIGN(SkCanvasVideoRendererTest);
};
+static SkBitmap AllocBitmap(int width, int height) {
+ SkBitmap bitmap;
+ bitmap.allocPixels(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType));
+ bitmap.eraseColor(0);
+ return bitmap;
+}
+
SkCanvasVideoRendererTest::SkCanvasVideoRendererTest()
: natural_frame_(VideoFrame::CreateBlackFrame(gfx::Size(kWidth, kHeight))),
larger_frame_(VideoFrame::CreateBlackFrame(
gfx::Rect(6, 6, 8, 6),
gfx::Size(8, 6),
base::TimeDelta::FromMilliseconds(4))),
- fast_path_device_(SkBitmap::kARGB_8888_Config, kWidth, kHeight, true),
- fast_path_canvas_(&fast_path_device_),
- slow_path_device_(SkBitmap::kARGB_8888_Config, kWidth, kHeight, false),
- slow_path_canvas_(&slow_path_device_) {
+ target_canvas_(AllocBitmap(kWidth, kHeight)) {
// Give each frame a unique timestamp.
- natural_frame_->SetTimestamp(base::TimeDelta::FromMilliseconds(1));
- larger_frame_->SetTimestamp(base::TimeDelta::FromMilliseconds(2));
- smaller_frame_->SetTimestamp(base::TimeDelta::FromMilliseconds(3));
+ natural_frame_->set_timestamp(base::TimeDelta::FromMilliseconds(1));
+ larger_frame_->set_timestamp(base::TimeDelta::FromMilliseconds(2));
+ smaller_frame_->set_timestamp(base::TimeDelta::FromMilliseconds(3));
// Make sure the cropped video frame's aspect ratio matches the output device.
// Update cropped_frame_'s crop dimensions if this is not the case.
- EXPECT_EQ(cropped_frame()->natural_size().width() * kHeight,
- cropped_frame()->natural_size().height() * kWidth);
+ EXPECT_EQ(cropped_frame()->visible_rect().width() * kHeight,
+ cropped_frame()->visible_rect().height() * kWidth);
// Fill in the cropped frame's entire data with colors:
//
21, 21, 21, 21, 107, 107, 107, 107,
};
- media::CopyYPlane(cropped_y_plane, 16, 16, cropped_frame());
- media::CopyUPlane(cropped_u_plane, 8, 8, cropped_frame());
- media::CopyVPlane(cropped_v_plane, 8, 8, cropped_frame());
+ media::CopyYPlane(cropped_y_plane, 16, 16, cropped_frame().get());
+ media::CopyUPlane(cropped_u_plane, 8, 8, cropped_frame().get());
+ media::CopyVPlane(cropped_v_plane, 8, 8, cropped_frame().get());
}
SkCanvasVideoRendererTest::~SkCanvasVideoRendererTest() {}
void SkCanvasVideoRendererTest::PaintWithoutFrame(SkCanvas* canvas) {
- renderer_.Paint(NULL, canvas, kNaturalRect, 0xFF);
+ renderer_.Paint(NULL,
+ canvas,
+ kNaturalRect,
+ 0xFF,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_0);
}
-void SkCanvasVideoRendererTest::Paint(VideoFrame* video_frame,
- SkCanvas* canvas,
- Color color) {
+void SkCanvasVideoRendererTest::Paint(
+ const scoped_refptr<VideoFrame>& video_frame,
+ SkCanvas* canvas,
+ Color color) {
+ PaintRotated(video_frame,
+ canvas,
+ kNaturalRect,
+ color,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_0);
+}
+
+void SkCanvasVideoRendererTest::PaintRotated(
+ const scoped_refptr<VideoFrame>& video_frame,
+ SkCanvas* canvas,
+ const gfx::RectF& dest_rect,
+ Color color,
+ SkXfermode::Mode mode,
+ VideoRotation video_rotation) {
switch (color) {
case kNone:
break;
case kRed:
- media::FillYUV(video_frame, 76, 84, 255);
+ media::FillYUV(video_frame.get(), 76, 84, 255);
break;
case kGreen:
- media::FillYUV(video_frame, 149, 43, 21);
+ media::FillYUV(video_frame.get(), 149, 43, 21);
break;
case kBlue:
- media::FillYUV(video_frame, 29, 255, 107);
+ media::FillYUV(video_frame.get(), 29, 255, 107);
break;
}
- renderer_.Paint(video_frame, canvas, kNaturalRect, 0xFF);
+ renderer_.Paint(video_frame, canvas, dest_rect, 0xFF, mode, video_rotation);
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_NoFrame) {
- // Test that black gets painted over canvas.
- FillCanvas(fast_path_canvas(), SK_ColorRED);
- PaintWithoutFrame(fast_path_canvas());
- EXPECT_EQ(SK_ColorBLACK, GetColor(fast_path_canvas()));
+void SkCanvasVideoRendererTest::Copy(
+ const scoped_refptr<VideoFrame>& video_frame,
+ SkCanvas* canvas) {
+ renderer_.Copy(video_frame, canvas);
}
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_NoFrame) {
+TEST_F(SkCanvasVideoRendererTest, NoFrame) {
// Test that black gets painted over canvas.
- FillCanvas(slow_path_canvas(), SK_ColorRED);
- PaintWithoutFrame(slow_path_canvas());
- EXPECT_EQ(SK_ColorBLACK, GetColor(slow_path_canvas()));
+ FillCanvas(target_canvas(), SK_ColorRED);
+ PaintWithoutFrame(target_canvas());
+ EXPECT_EQ(SK_ColorBLACK, GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_Natural) {
- Paint(natural_frame(), fast_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(fast_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, TransparentFrame) {
+ FillCanvas(target_canvas(), SK_ColorRED);
+ PaintRotated(
+ VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)).get(),
+ target_canvas(),
+ kNaturalRect,
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_0);
+ EXPECT_EQ(static_cast<SkColor>(SK_ColorRED), GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_Natural) {
- Paint(natural_frame(), slow_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, TransparentFrameSrcMode) {
+ FillCanvas(target_canvas(), SK_ColorRED);
+ // SRC mode completely overwrites the buffer.
+ PaintRotated(
+ VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)).get(),
+ target_canvas(),
+ kNaturalRect,
+ kNone,
+ SkXfermode::kSrc_Mode,
+ VIDEO_ROTATION_0);
+ EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
+ GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_Larger) {
- Paint(natural_frame(), fast_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(fast_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, CopyTransparentFrame) {
+ FillCanvas(target_canvas(), SK_ColorRED);
+ Copy(VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)).get(),
+ target_canvas());
+ EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
+ GetColor(target_canvas()));
+}
- Paint(larger_frame(), fast_path_canvas(), kBlue);
- EXPECT_EQ(SK_ColorBLUE, GetColor(fast_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, Natural) {
+ Paint(natural_frame(), target_canvas(), kRed);
+ EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_Larger) {
- Paint(natural_frame(), slow_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, Larger) {
+ Paint(natural_frame(), target_canvas(), kRed);
+ EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
- Paint(larger_frame(), slow_path_canvas(), kBlue);
- EXPECT_EQ(SK_ColorBLUE, GetColor(slow_path_canvas()));
+ Paint(larger_frame(), target_canvas(), kBlue);
+ EXPECT_EQ(SK_ColorBLUE, GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_Smaller) {
- Paint(natural_frame(), fast_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(fast_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, Smaller) {
+ Paint(natural_frame(), target_canvas(), kRed);
+ EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
- Paint(smaller_frame(), fast_path_canvas(), kBlue);
- EXPECT_EQ(SK_ColorBLUE, GetColor(fast_path_canvas()));
+ Paint(smaller_frame(), target_canvas(), kBlue);
+ EXPECT_EQ(SK_ColorBLUE, GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_Smaller) {
- Paint(natural_frame(), slow_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
-
- Paint(smaller_frame(), slow_path_canvas(), kBlue);
- EXPECT_EQ(SK_ColorBLUE, GetColor(slow_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, NoTimestamp) {
+ VideoFrame* video_frame = natural_frame().get();
+ video_frame->set_timestamp(media::kNoTimestamp());
+ Paint(video_frame, target_canvas(), kRed);
+ EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_NoTimestamp) {
- VideoFrame* video_frame = natural_frame();
- video_frame->SetTimestamp(media::kNoTimestamp());
- Paint(video_frame, fast_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(fast_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, SameVideoFrame) {
+ Paint(natural_frame(), target_canvas(), kRed);
+ EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
+
+ // Slow paints can get cached, expect the old color value.
+ Paint(natural_frame(), target_canvas(), kBlue);
+ EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
}
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_NoTimestamp) {
- VideoFrame* video_frame = natural_frame();
- video_frame->SetTimestamp(media::kNoTimestamp());
- Paint(video_frame, slow_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, CroppedFrame) {
+ Paint(cropped_frame(), target_canvas(), kNone);
+ // Check the corners.
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), 0, 0));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(target_canvas(), kWidth - 1, 0));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(target_canvas(), 0, kHeight - 1));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(target_canvas(), kWidth - 1,
+ kHeight - 1));
+ // Check the interior along the border between color regions. Note that we're
+ // bilinearly upscaling, so we'll need to take care to pick sample points that
+ // are just outside the "zone of resampling".
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), kWidth * 1 / 8 - 1,
+ kHeight * 1 / 6 - 1));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(target_canvas(), kWidth * 3 / 8,
+ kHeight * 1 / 6 - 1));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(target_canvas(), kWidth * 1 / 8 - 1,
+ kHeight * 3 / 6));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(target_canvas(), kWidth * 3 / 8,
+ kHeight * 3 / 6));
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_SameVideoFrame) {
- Paint(natural_frame(), fast_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(fast_path_canvas()));
+TEST_F(SkCanvasVideoRendererTest, CroppedFrame_NoScaling) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ const gfx::Rect crop_rect = cropped_frame()->visible_rect();
- // Fast paints always get painted to the canvas.
- Paint(natural_frame(), fast_path_canvas(), kBlue);
- EXPECT_EQ(SK_ColorBLUE, GetColor(fast_path_canvas()));
-}
+ // Force painting to a non-zero position on the destination bitmap, to check
+ // if the coordinates are calculated properly.
+ const int offset_x = 10;
+ const int offset_y = 15;
+ canvas.translate(offset_x, offset_y);
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_SameVideoFrame) {
- Paint(natural_frame(), slow_path_canvas(), kRed);
- EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
+ // Create a destination canvas with dimensions and scale which would not
+ // cause scaling.
+ canvas.scale(static_cast<SkScalar>(crop_rect.width()) / kWidth,
+ static_cast<SkScalar>(crop_rect.height()) / kHeight);
- // Slow paints can get cached, expect the old color value.
- Paint(natural_frame(), slow_path_canvas(), kBlue);
- EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
+ Paint(cropped_frame(), &canvas, kNone);
+
+ // Check the corners.
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, offset_x, offset_y));
+ EXPECT_EQ(SK_ColorRED,
+ GetColorAt(&canvas, offset_x + crop_rect.width() - 1, offset_y));
+ EXPECT_EQ(SK_ColorGREEN,
+ GetColorAt(&canvas, offset_x, offset_y + crop_rect.height() - 1));
+ EXPECT_EQ(SK_ColorBLUE,
+ GetColorAt(&canvas,
+ offset_x + crop_rect.width() - 1,
+ offset_y + crop_rect.height() - 1));
}
-TEST_F(SkCanvasVideoRendererTest, FastPaint_CroppedFrame) {
- Paint(cropped_frame(), fast_path_canvas(), kNone);
+TEST_F(SkCanvasVideoRendererTest, Video_Rotation_90) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ PaintRotated(cropped_frame(),
+ &canvas,
+ kNaturalRect,
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_90);
// Check the corners.
- EXPECT_EQ(SK_ColorBLACK, GetColorAt(fast_path_canvas(), 0, 0));
- EXPECT_EQ(SK_ColorRED, GetColorAt(fast_path_canvas(), kWidth - 1, 0));
- EXPECT_EQ(SK_ColorGREEN, GetColorAt(fast_path_canvas(), 0, kHeight - 1));
- EXPECT_EQ(SK_ColorBLUE, GetColorAt(fast_path_canvas(), kWidth - 1,
- kHeight - 1));
- // Check the interior along the border between color regions. Note that we're
- // bilinearly upscaling, so we'll need to take care to pick sample points that
- // are just outside the "zone of resampling".
- // TODO(sheu): commenting out two checks due to http://crbug.com/158462.
-#if 0
- EXPECT_EQ(SK_ColorBLACK, GetColorAt(fast_path_canvas(), kWidth * 1 / 8 - 1,
- kHeight * 1 / 6 - 1));
-#endif
- EXPECT_EQ(SK_ColorRED, GetColorAt(fast_path_canvas(), kWidth * 3 / 8,
- kHeight * 1 / 6 - 1));
-#if 0
- EXPECT_EQ(SK_ColorGREEN, GetColorAt(fast_path_canvas(), kWidth * 1 / 8 - 1,
- kHeight * 3 / 6));
-#endif
- EXPECT_EQ(SK_ColorBLUE, GetColorAt(fast_path_canvas(), kWidth * 3 / 8,
- kHeight * 3 / 6));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, 0));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, 0, kHeight - 1));
}
-TEST_F(SkCanvasVideoRendererTest, SlowPaint_CroppedFrame) {
- Paint(cropped_frame(), slow_path_canvas(), kNone);
+TEST_F(SkCanvasVideoRendererTest, Video_Rotation_180) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ PaintRotated(cropped_frame(),
+ &canvas,
+ kNaturalRect,
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_180);
// Check the corners.
- EXPECT_EQ(SK_ColorBLACK, GetColorAt(slow_path_canvas(), 0, 0));
- EXPECT_EQ(SK_ColorRED, GetColorAt(slow_path_canvas(), kWidth - 1, 0));
- EXPECT_EQ(SK_ColorGREEN, GetColorAt(slow_path_canvas(), 0, kHeight - 1));
- EXPECT_EQ(SK_ColorBLUE, GetColorAt(slow_path_canvas(), kWidth - 1,
- kHeight - 1));
- // Check the interior along the border between color regions. Note that we're
- // bilinearly upscaling, so we'll need to take care to pick sample points that
- // are just outside the "zone of resampling".
- EXPECT_EQ(SK_ColorBLACK, GetColorAt(slow_path_canvas(), kWidth * 1 / 8 - 1,
- kHeight * 1 / 6 - 1));
- EXPECT_EQ(SK_ColorRED, GetColorAt(slow_path_canvas(), kWidth * 3 / 8,
- kHeight * 1 / 6 - 1));
- EXPECT_EQ(SK_ColorGREEN, GetColorAt(slow_path_canvas(), kWidth * 1 / 8 - 1,
- kHeight * 3 / 6));
- EXPECT_EQ(SK_ColorBLUE, GetColorAt(slow_path_canvas(), kWidth * 3 / 8,
- kHeight * 3 / 6));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, 0));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, 0, kHeight - 1));
+}
+
+TEST_F(SkCanvasVideoRendererTest, Video_Rotation_270) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ PaintRotated(cropped_frame(),
+ &canvas,
+ kNaturalRect,
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_270);
+ // Check the corners.
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, 0));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, 0, kHeight - 1));
+}
+
+TEST_F(SkCanvasVideoRendererTest, Video_Translate) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ FillCanvas(&canvas, SK_ColorMAGENTA);
+
+ PaintRotated(cropped_frame(),
+ &canvas,
+ gfx::Rect(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_0);
+ // Check the corners of quadrant 2 and 4.
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+ EXPECT_EQ(SK_ColorMAGENTA,
+ GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+}
+
+TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_90) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ FillCanvas(&canvas, SK_ColorMAGENTA);
+
+ const gfx::Rect crop_rect = cropped_frame()->visible_rect();
+ PaintRotated(cropped_frame(),
+ &canvas,
+ gfx::Rect(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_90);
+ // Check the corners of quadrant 2 and 4.
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+ EXPECT_EQ(SK_ColorMAGENTA,
+ GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+}
+
+TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_180) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ FillCanvas(&canvas, SK_ColorMAGENTA);
+
+ PaintRotated(cropped_frame(),
+ &canvas,
+ gfx::Rect(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_180);
+ // Check the corners of quadrant 2 and 4.
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+ EXPECT_EQ(SK_ColorMAGENTA,
+ GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+}
+
+TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_270) {
+ SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+ FillCanvas(&canvas, SK_ColorMAGENTA);
+
+ PaintRotated(cropped_frame(),
+ &canvas,
+ gfx::Rect(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
+ kNone,
+ SkXfermode::kSrcOver_Mode,
+ VIDEO_ROTATION_270);
+ // Check the corners of quadrant 2 and 4.
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+ EXPECT_EQ(SK_ColorMAGENTA,
+ GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
+ EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
+ EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
+ EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
+ EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
}
} // namespace media
projects / platform / framework / web / crosswalk.git / blobdiff