media: Optimize HW Video to 2D Canvas copy.

cc/resources/media/skcanvas_video_renderer_unittest.cc

 // 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 "cc/resources/media/skcanvas_video_renderer.h"
+#include "media/base/media.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/SkCanvas.h"
-#include "media/filters/skcanvas_video_renderer.h"
 
 using media::VideoFrame;
 
-namespace media {
+namespace cc {
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const gfx::Rect kNaturalRect(0, 0, kWidth, kHeight);
 
 // Helper for filling a |canvas| with a solid |color|.
 void FillCanvas(SkCanvas* canvas, SkColor color) {
   canvas->clear(color);
 }
 
@@ skipping 54 matching lines @@
 
 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::Size(kWidth * 2, kHeight * 2))),
-      smaller_frame_(VideoFrame::CreateBlackFrame(
-          gfx::Size(kWidth / 2, kHeight / 2))),
-      cropped_frame_(VideoFrame::CreateFrame(
-          VideoFrame::YV12,
-          gfx::Size(16, 16),
-          gfx::Rect(6, 6, 8, 6),
-          gfx::Size(8, 6),
-          base::TimeDelta::FromMilliseconds(4))),
+      larger_frame_(
+          VideoFrame::CreateBlackFrame(gfx::Size(kWidth * 2, kHeight * 2))),
+      smaller_frame_(
+          VideoFrame::CreateBlackFrame(gfx::Size(kWidth / 2, kHeight / 2))),
+      cropped_frame_(
+          VideoFrame::CreateFrame(VideoFrame::YV12,
+                                  gfx::Size(16, 16),
+                                  gfx::Rect(6, 6, 8, 6),
+                                  gfx::Size(8, 6),
+                                  base::TimeDelta::FromMilliseconds(4))),
       target_canvas_(AllocBitmap(kWidth, kHeight)) {
+  media::InitializeMediaLibraryForTesting();
+
   // Give each frame a unique timestamp.
   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()->visible_rect().width() * kHeight,
             cropped_frame()->visible_rect().height() * kWidth);
 
@@ skipping 22 matching lines @@
   //   Bl Bl R  R  R  R  R  R
   //   G  G  B  B  B  B  B  B
   //   G  G  B  B  B  B  B  B
   //   G  G  B  B  B  B  B  B
   //   G  G  B  B  B  B  B  B
   //
   // Each color region in the cropped frame is on a 2x2 block granularity, to
   // avoid sharing UV samples between regions.
 
   static const uint8 cropped_y_plane[] = {
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-      0,   0,   0,   0,   0,   0,   0,   0, 76, 76, 76, 76, 76, 76, 76, 76,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
-    149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      0,   0,   0,   0,   0,   0,   0,   0,   76, 76, 76, 76, 76, 76, 76, 76,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
+      149, 149, 149, 149, 149, 149, 149, 149, 29, 29, 29, 29, 29, 29, 29, 29,
   };
 
   static const uint8 cropped_u_plane[] = {
-    128, 128, 128, 128,  84,  84,  84,  84,
-    128, 128, 128, 128,  84,  84,  84,  84,
-    128, 128, 128, 128,  84,  84,  84,  84,
-    128, 128, 128, 128,  84,  84,  84,  84,
-     43,  43,  43,  43, 255, 255, 255, 255,
-     43,  43,  43,  43, 255, 255, 255, 255,
-     43,  43,  43,  43, 255, 255, 255, 255,
-     43,  43,  43,  43, 255, 255, 255, 255,
+      128, 128, 128, 128, 84,  84,  84,  84,  128, 128, 128, 128, 84,
+      84,  84,  84,  128, 128, 128, 128, 84,  84,  84,  84,  128, 128,
+      128, 128, 84,  84,  84,  84,  43,  43,  43,  43,  255, 255, 255,
+      255, 43,  43,  43,  43,  255, 255, 255, 255, 43,  43,  43,  43,
+      255, 255, 255, 255, 43,  43,  43,  43,  255, 255, 255, 255,
   };
   static const uint8 cropped_v_plane[] = {
-    128, 128, 128, 128, 255, 255, 255, 255,
-    128, 128, 128, 128, 255, 255, 255, 255,
-    128, 128, 128, 128, 255, 255, 255, 255,
-    128, 128, 128, 128, 255, 255, 255, 255,
-     21,  21,  21,  21, 107, 107, 107, 107,
-     21,  21,  21,  21, 107, 107, 107, 107,
-     21,  21,  21,  21, 107, 107, 107, 107,
-     21,  21,  21,  21, 107, 107, 107, 107,
+      128, 128, 128, 128, 255, 255, 255, 255, 128, 128, 128, 128, 255,
+      255, 255, 255, 128, 128, 128, 128, 255, 255, 255, 255, 128, 128,
+      128, 128, 255, 255, 255, 255, 21,  21,  21,  21,  107, 107, 107,
+      107, 21,  21,  21,  21,  107, 107, 107, 107, 21,  21,  21,  21,
+      107, 107, 107, 107, 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());
 }
 
-SkCanvasVideoRendererTest::~SkCanvasVideoRendererTest() {}
+SkCanvasVideoRendererTest::~SkCanvasVideoRendererTest() {
+}
 
 void SkCanvasVideoRendererTest::PaintWithoutFrame(SkCanvas* canvas) {
-  renderer_.Paint(NULL, canvas, kNaturalRect, 0xFF);
+  renderer_.Paint(NULL, canvas, kNaturalRect, 0xFF, 0);
 }
 
 void SkCanvasVideoRendererTest::Paint(VideoFrame* video_frame,
                                       SkCanvas* canvas,
                                       Color color) {
   switch (color) {
     case kNone:
       break;
     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;
   }
-  renderer_.Paint(video_frame, canvas, kNaturalRect, 0xFF);
+  renderer_.Paint(video_frame, canvas, kNaturalRect, 0xFF, 0);
 }
 
 TEST_F(SkCanvasVideoRendererTest, NoFrame) {
   // Test that black gets painted over canvas.
   FillCanvas(target_canvas(), SK_ColorRED);
   PaintWithoutFrame(target_canvas());
   EXPECT_EQ(SK_ColorBLACK, GetColor(target_canvas()));
 }
 
 TEST_F(SkCanvasVideoRendererTest, TransparentFrame) {
   // Test that we don't blend with existing canvas contents.
   FillCanvas(target_canvas(), SK_ColorRED);
   Paint(VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)),
         target_canvas(),
         kNone);
-  EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
-            GetColor(target_canvas()));
+  EXPECT_EQ(static_cast<SkColor>(SK_ColorRED), GetColor(target_canvas()));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Natural) {
   Paint(natural_frame(), target_canvas(), kRed);
   EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Larger) {
   Paint(natural_frame(), target_canvas(), kRed);
   EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
@@ skipping 23 matching lines @@
 
   // 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, 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_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));
+  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));
+  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, CroppedFrame_NoScaling) {
   SkCanvas canvas(AllocBitmap(kWidth, kHeight));
   const gfx::Rect crop_rect = cropped_frame()->visible_rect();
 
   // 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;
@@ skipping 11 matching lines @@
   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));
 }
 
-}  // namespace media
+}  // namespace cc