Plumb through cropped output size for VideoFrame

media/filters/skcanvas_video_renderer_unittest.cc

Index: media/filters/skcanvas_video_renderer_unittest.cc
diff --git a/media/filters/skcanvas_video_renderer_unittest.cc b/media/filters/skcanvas_video_renderer_unittest.cc
index a7ac30c477fb7f4c9d7e27d8eedc2f8470b0f5ac..7ab0c58e6435f708cb6ee558950903e222cbd01f 100644
--- a/media/filters/skcanvas_video_renderer_unittest.cc
+++ b/media/filters/skcanvas_video_renderer_unittest.cc
@@ -27,9 +27,13 @@ void FillCanvas(SkCanvas* canvas, SkColor color) {
 
 // Helper for returning the color of a solid |canvas|.
 SkColor GetColor(SkCanvas* canvas) {
+  return GetColorAt(canvas, 0, 0);
+}
+
+SkColor GetColorAt(SkCanvas* canvas, int x, int y) {
   const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(false);
   bitmap.lockPixels();
-  SkColor c = bitmap.getColor(0, 0);
+  SkColor c = bitmap.getColor(x, y);
   bitmap.unlockPixels();
   return c;
 }
@@ -38,6 +42,7 @@ class SkCanvasVideoRendererTest : public testing::Test {
  public:
   enum Color {
     kRed,
+    kGreen,
     kBlue,
   };
 
@@ -55,6 +60,7 @@ class SkCanvasVideoRendererTest : public testing::Test {
   VideoFrame* natural_frame() { return natural_frame_; }
   VideoFrame* larger_frame() { return larger_frame_; }
   VideoFrame* smaller_frame() { return smaller_frame_; }
+  VideoFrame* cropped_frame() { return cropped_frame_; }
 
   // Getters for canvases that trigger the various painting paths.
   SkCanvas* fast_path_canvas() { return &fast_path_canvas_; }
@@ -66,6 +72,7 @@ class SkCanvasVideoRendererTest : public testing::Test {
   scoped_refptr<VideoFrame> natural_frame_;
   scoped_refptr<VideoFrame> larger_frame_;
   scoped_refptr<VideoFrame> smaller_frame_;
+  scoped_refptr<VideoFrame> cropped_frame_;
 
   SkDevice fast_path_device_;
   SkCanvas fast_path_canvas_;
@@ -81,14 +88,51 @@ SkCanvasVideoRendererTest::SkCanvasVideoRendererTest()
           gfx::Size(kWidth * 2, kHeight * 2))),
       smaller_frame_(VideoFrame::CreateBlackFrame(
           gfx::Size(kWidth / 2, kHeight / 2))),
+      cropped_frame_(VideoFrame::CreateFrame(
+          VideoFrame::YV12,
+          gfx::Size(4, 4),
+          gfx::Rect(1, 1, 3, 2),
+          gfx::Rect(3, 2),
+          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_) {
+      slow_path_canvas_(&slow_path_device_),
   // 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));
+
+  // 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().x() * kHeight,
+      cropped_frame().natural_size().y() * kWidth);
+
+  // Fill in the cropped frame's entire data with colors:
+  //   Bl Bl R  R
+  //   Bl Bl R  R

[Ami GONE FROM CHROMIUM, 2012/10/26 02:46:52]

s/Bl/B/g :)

[sheu, 2012/10/26 18:45:23]

"Bl" for "black".  I realize that the colors in the actual static arrays aren't
correct -- these are fixed in the next revision.

+  //   G  G  B  B
+  //   G  G  B  B
+  // The visible frame (as set by its visible_rect_) has contents:
+  //   Bl R  R
+  //   G  B  B
+  static const uint8 y_plane[] = {
+      0,   0,  76,  76,
+      0,   0,  76,  76,
+    149, 149,  29,  29,
+    149, 149,  29,  29,
+  };
+  static const uint8 u_plane[] = {
+     84,  43,
+    255, 128,
+  };
+  static const uint8 v_plane[] = {
+    255,  21,
+    107, 128,
+  };
+  media::CopyYPlane(y_plane, 4, 4, cropped_frame());
+  media::CopyUPlane(u_plane, 2, 2, cropped_frame());
+  media::CopyVPlane(v_plane, 2, 2, cropped_frame());
 }
 
 SkCanvasVideoRendererTest::~SkCanvasVideoRendererTest() {}
@@ -104,6 +148,9 @@ void SkCanvasVideoRendererTest::Paint(VideoFrame* video_frame,
     case kRed:
       media::FillYUV(video_frame, 76, 84, 255);
       break;
+    case kGreen:
+      media::FillYUV(video_frame, 149, 43, 21);
+      break;
     case kBlue:
       media::FillYUV(video_frame, 29, 255, 107);
       break;
@@ -199,4 +246,42 @@ TEST_F(SkCanvasVideoRendererTest, SlowPaint_SameVideoFrame) {
   EXPECT_EQ(SK_ColorRED, GetColor(slow_path_canvas()));
 }
 
+TEST_F(SkCanvasVideoRendererTest, FastPaint_CroppedFrame) {
+  renderer_.Paint(cropped_frame(), fast_path_canvas(), kNaturalRect, 0xFF);
+  // 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.
+  EXPECT_EQ(SK_ColorBLACK, GetColorAt(fast_path_canvas(), kWidth / 3 - 1,
+                                      kHeight / 2 - 1));
+  EXPECT_EQ(SK_ColorRED, GetColorAt(fast_path_canvas(), kWidth / 3,
+                                    kHeight / 2 - 1));
+  EXPECT_EQ(SK_ColorGREEN, GetColorAt(fast_path_canvas(), kWidth / 3 - 1,
+                                      kHeight / 2));
+  EXPECT_EQ(SK_ColorBLUE, GetColorAt(fast_path_canvas(), kWidth / 3,
+                                     kHeight / 2));
+}
+
+TEST_F(SkCanvasVideoRendererTest, SlowPaint_CroppedFrame) {
+  renderer_.Paint(cropped_frame(), slow_path_canvas(), kNaturalRect, 0xFF);
+  // 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.
+  EXPECT_EQ(SK_ColorBLACK, GetColorAt(slow_path_canvas(), kWidth / 3 - 1,
+                                      kHeight / 2 - 1));
+  EXPECT_EQ(SK_ColorRED, GetColorAt(slow_path_canvas(), kWidth / 3,
+                                    kHeight / 2 - 1));
+  EXPECT_EQ(SK_ColorGREEN, GetColorAt(slow_path_canvas(), kWidth / 3 - 1,
+                                      kHeight / 2));
+  EXPECT_EQ(SK_ColorBLUE, GetColorAt(slow_path_canvas(), kWidth / 3,
+                                     kHeight / 2));
+}
+
 }  // namespace media