Fixed YUV Video quads when their visible_content_rect != their rect.

cc/output/renderer_pixeltest.cc

 // Copyright 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/message_loop/message_loop.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/video_resource_updater.h"
@@ skipping 181 matching lines @@
 }
 
 void CreateTestYUVVideoDrawQuad_FromVideoFrame(
     const SharedQuadState* shared_state,
     scoped_refptr<media::VideoFrame> video_frame,
     uint8 alpha_value,
     const gfx::RectF& tex_coord_rect,
     RenderPass* render_pass,
     VideoResourceUpdater* video_resource_updater,
     const gfx::Rect& rect,
+    const gfx::Rect& visible_rect,
     ResourceProvider* resource_provider) {
   const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
   const YUVVideoDrawQuad::ColorSpace color_space =
       (video_frame->format() == media::VideoFrame::YV12J
            ? YUVVideoDrawQuad::JPEG
            : YUVVideoDrawQuad::REC_601);
   const gfx::Rect opaque_rect(0, 0, 0, 0);
 
   if (with_alpha) {
     memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
@@ skipping 29 matching lines @@
   ResourceProvider::ResourceId a_resource = 0;
   if (with_alpha) {
     a_resource = resource_provider->CreateResourceFromTextureMailbox(
         resources.mailboxes[media::VideoFrame::kAPlane],
         SingleReleaseCallbackImpl::Create(
             resources.release_callbacks[media::VideoFrame::kAPlane]));
   }
 
   YUVVideoDrawQuad* yuv_quad =
       render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
-  yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect,
-                   video_frame->coded_size(), y_resource, u_resource,
-                   v_resource, a_resource, color_space);
+  yuv_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
+                   tex_coord_rect, video_frame->coded_size(), y_resource,
+                   u_resource, v_resource, a_resource, color_space);
 }
 
 void CreateTestYUVVideoDrawQuad_Striped(
     const SharedQuadState* shared_state,
     media::VideoFrame::Format format,
     bool is_transparent,
     const gfx::RectF& tex_coord_rect,
     RenderPass* render_pass,
     VideoResourceUpdater* video_resource_updater,
     const gfx::Rect& rect,
+    const gfx::Rect& visible_rect,
     ResourceProvider* resource_provider) {
   scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
       format, rect.size(), rect, rect.size(), base::TimeDelta());
 
   // YUV values representing a striped pattern, for validating texture
   // coordinates for sampling.
   uint8_t y_value = 0;
   uint8_t u_value = 0;
   uint8_t v_value = 0;
   for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
@@ skipping 11 matching lines @@
                      video_frame->stride(media::VideoFrame::kVPlane) * i;
     for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane);
          ++j) {
       u_row[j] = (u_value += 3);
       v_row[j] = (v_value += 5);
     }
   }
   uint8 alpha_value = is_transparent ? 0 : 128;
   CreateTestYUVVideoDrawQuad_FromVideoFrame(
       shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
-      video_resource_updater, rect, resource_provider);
+      video_resource_updater, rect, visible_rect, resource_provider);
 }
 
 // Creates a video frame of size background_size filled with yuv_background,
 // and then draws a foreground rectangle in a different color on top of
 // that. The foreground rectangle must have coordinates that are divisible
 // by 2 because YUV is a block format.
 void CreateTestYUVVideoDrawQuad_TwoColor(
     const SharedQuadState* shared_state,
     media::VideoFrame::Format format,
     bool is_transparent,
     const gfx::RectF& tex_coord_rect,
     const gfx::Size& background_size,
+    const gfx::Rect& visible_rect,
     uint8 y_background,
     uint8 u_background,
     uint8 v_background,
     const gfx::Rect& foreground_rect,
     uint8 y_foreground,
     uint8 u_foreground,
     uint8 v_foreground,
     RenderPass* render_pass,
     VideoResourceUpdater* video_resource_updater,
     ResourceProvider* resource_provider) {
@@ skipping 31 matching lines @@
       for (int x = sample_rect.x(); x < sample_rect.right(); ++x) {
         size_t offset = y * video_frame->stride(planes[i]) + x;
         video_frame->data(planes[i])[offset] = yuv_foreground[i];
       }
     }
   }
 
   uint8 alpha_value = 255;
   CreateTestYUVVideoDrawQuad_FromVideoFrame(
       shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
-      video_resource_updater, rect, resource_provider);
+      video_resource_updater, rect, visible_rect, resource_provider);
 }
 
 void CreateTestYUVVideoDrawQuad_Solid(
     const SharedQuadState* shared_state,
     media::VideoFrame::Format format,
     bool is_transparent,
     const gfx::RectF& tex_coord_rect,
     uint8 y,
     uint8 u,
     uint8 v,
     RenderPass* render_pass,
     VideoResourceUpdater* video_resource_updater,
     const gfx::Rect& rect,
+    const gfx::Rect& visible_rect,
     ResourceProvider* resource_provider) {
   scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
       format, rect.size(), rect, rect.size(), base::TimeDelta());
 
   // YUV values of a solid, constant, color. Useful for testing that color
   // space/color range are being handled properly.
   memset(video_frame->data(media::VideoFrame::kYPlane), y,
          video_frame->stride(media::VideoFrame::kYPlane) *
              video_frame->rows(media::VideoFrame::kYPlane));
   memset(video_frame->data(media::VideoFrame::kUPlane), u,
          video_frame->stride(media::VideoFrame::kUPlane) *
              video_frame->rows(media::VideoFrame::kUPlane));
   memset(video_frame->data(media::VideoFrame::kVPlane), v,
          video_frame->stride(media::VideoFrame::kVPlane) *
              video_frame->rows(media::VideoFrame::kVPlane));
 
   uint8 alpha_value = is_transparent ? 0 : 128;
   CreateTestYUVVideoDrawQuad_FromVideoFrame(
       shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
-      video_resource_updater, rect, resource_provider);
+      video_resource_updater, rect, visible_rect, resource_provider);
 }
 
 typedef ::testing::Types<GLRenderer,
                          SoftwareRenderer,
                          GLRendererWithExpandedViewport,
                          SoftwareRendererWithExpandedViewport> RendererTypes;
 TYPED_TEST_CASE(RendererPixelTest, RendererTypes);
 
 template <typename RendererType>
 class SoftwareRendererPixelTest : public RendererPixelTest<RendererType> {};
@@ skipping 411 matching lines @@
 TYPED_TEST(IntersectingQuadGLPixelTest, YUVVideoQuads) {
   this->SetupQuadStateAndRenderPass();
   gfx::Rect inner_rect(
       ((this->quad_rect_.x() + (this->quad_rect_.width() / 4)) & ~0xF),
       ((this->quad_rect_.y() + (this->quad_rect_.height() / 4)) & ~0xF),
       (this->quad_rect_.width() / 2) & ~0xF,
       (this->quad_rect_.height() / 2) & ~0xF);
 
   CreateTestYUVVideoDrawQuad_TwoColor(
       this->front_quad_state_, media::VideoFrame::YV12J, false,
-      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(), 0, 128, 128,
-      inner_rect, 29, 255, 107, this->render_pass_.get(),
-      this->video_resource_updater_.get(), this->resource_provider_.get());
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(),
+      this->quad_rect_, 0, 128, 128, inner_rect, 29, 255, 107,
+      this->render_pass_.get(), this->video_resource_updater_.get(),
+      this->resource_provider_.get());
 
   CreateTestYUVVideoDrawQuad_TwoColor(
       this->back_quad_state_, media::VideoFrame::YV12J, false,
-      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(), 149, 43, 21,
-      inner_rect, 0, 128, 128, this->render_pass_.get(),
-      this->video_resource_updater2_.get(), this->resource_provider_.get());
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(),
+      this->quad_rect_, 149, 43, 21, inner_rect, 0, 128, 128,
+      this->render_pass_.get(), this->video_resource_updater2_.get(),
+      this->resource_provider_.get());
 
   SCOPED_TRACE("IntersectingVideoQuads");
   this->template AppendBackgroundAndRunTest<YUVVideoDrawQuad>(
       FuzzyPixelOffByOneComparator(false));
 }
 
 // TODO(skaslev): The software renderer does not support non-premultplied alpha.
 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) {
   gfx::Rect rect(this->device_viewport_size_);
 
@@ skipping 82 matching lines @@
         static_cast<float>(green_rect.y()) / background_size.height(),
         static_cast<float>(green_rect.width()) / background_size.width(),
         static_cast<float>(green_rect.height()) / background_size.height());
 
     // YUV of (149,43,21) should be green (0,255,0) in RGB.
     // Create a video frame that has a non-green background rect, with a
     // green sub-rectangle that should be the only thing displayed in
     // the final image.  Bleeding will appear on all four sides of the video
     // if the tex coords are not clamped.
     CreateTestYUVVideoDrawQuad_TwoColor(
-        shared_state, format, false, tex_coord_rect, background_size, 0, 0, 0,
-        green_rect, 149, 43, 21, pass.get(), video_resource_updater_.get(),
-        resource_provider_.get());
+        shared_state, format, false, tex_coord_rect, background_size,
+        gfx::Rect(background_size), 0, 0, 0, green_rect, 149, 43, 21,
+        pass.get(), video_resource_updater_.get(), resource_provider_.get());
     pass_list->push_back(pass.Pass());
   }
 
   void SetUp() override {
     GLRendererPixelTest::SetUp();
     video_resource_updater_.reset(new VideoResourceUpdater(
         output_surface_->context_provider(), resource_provider_.get()));
   }
 
   scoped_ptr<VideoResourceUpdater> video_resource_updater_;
 };
 
 TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12,
                                      false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
                                      pass.get(), video_resource_updater_.get(),
-                                     rect, resource_provider_.get());
+                                     rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(
       this->RunPixelTest(&pass_list,
                          base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")),
                          FuzzyPixelOffByOneComparator(true)));
 }
 
+TEST_F(VideoGLRendererPixelTest, ClippedYUVRect) {
+  gfx::Rect viewport(this->device_viewport_size_);
+  gfx::Rect draw_rect(this->device_viewport_size_.width() * 1.5,
+                      this->device_viewport_size_.height() * 1.5);
+
+  RenderPassId id(1, 1);
+  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, viewport);
+
+  SharedQuadState* shared_state =
+      CreateTestSharedQuadState(gfx::Transform(), viewport, pass.get());
+
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12,
+                                     false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     draw_rect, viewport,
+                                     resource_provider_.get());
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  EXPECT_TRUE(this->RunPixelTest(
+      &pass_list, base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped.png")),
+      FuzzyPixelOffByOneComparator(true)));
+}
+
 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Intentionally sets frame format to I420 for testing coverage.
   CreateTestYUVVideoDrawQuad_Striped(
       shared_state, media::VideoFrame::I420, false,
       gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), pass.get(),
-      video_resource_updater_.get(), rect, resource_provider_.get());
+      video_resource_updater_.get(), rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // In MPEG color range YUV values of (15,128,128) should produce black.
   CreateTestYUVVideoDrawQuad_Solid(
       shared_state, media::VideoFrame::YV12, false,
       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(),
-      video_resource_updater_.get(), rect, resource_provider_.get());
+      video_resource_updater_.get(), rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // If we didn't get black out of the YUV values above, then we probably have a
   // color range issue.
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("black.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // YUV of (149,43,21) should be green (0,255,0) in RGB.
   CreateTestYUVVideoDrawQuad_Solid(
       shared_state, media::VideoFrame::YV12J, false,
       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(),
-      video_resource_updater_.get(), rect, resource_provider_.get());
+      video_resource_updater_.get(), rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 // Test that a YUV video doesn't bleed outside of its tex coords when the
@@ skipping 20 matching lines @@
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Dark grey in JPEG color range (in MPEG, this is black).
   CreateTestYUVVideoDrawQuad_Solid(
       shared_state, media::VideoFrame::YV12J, false,
       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(),
-      video_resource_updater_.get(), rect, resource_provider_.get());
+      video_resource_updater_.get(), rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(
       this->RunPixelTest(&pass_list,
                          base::FilePath(FILE_PATH_LITERAL("dark_grey.png")),
                          FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A,
                                      false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
                                      pass.get(), video_resource_updater_.get(),
-                                     rect, resource_provider_.get());
+                                     rect, rect, resource_provider_.get());
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A,
                                      true, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
                                      pass.get(), video_resource_updater_.get(),
-                                     rect, resource_provider_.get());
+                                     rect, rect, resource_provider_.get());
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
@@ skipping 1759 matching lines @@
           ? FILE_PATH_LITERAL("four_blue_green_checkers.png")
           : FILE_PATH_LITERAL("checkers_big.png");
   EXPECT_TRUE(this->RunPixelTest(&pass_list, base::FilePath(path),
                                  ExactPixelComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc