Enable sampling from DXGI NV12 formats in GLRenderer.

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 <stddef.h>
 #include <stdint.h>
 
 #include "base/message_loop/message_loop.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
@@ skipping 210 matching lines @@
             resources.release_callbacks.size());
 
   ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox(
       resources.mailboxes[media::VideoFrame::kYPlane],
       SingleReleaseCallbackImpl::Create(
           resources.release_callbacks[media::VideoFrame::kYPlane]));
   ResourceId u_resource = resource_provider->CreateResourceFromTextureMailbox(
       resources.mailboxes[media::VideoFrame::kUPlane],
       SingleReleaseCallbackImpl::Create(
           resources.release_callbacks[media::VideoFrame::kUPlane]));
-  ResourceId v_resource = resource_provider->CreateResourceFromTextureMailbox(
-      resources.mailboxes[media::VideoFrame::kVPlane],
-      SingleReleaseCallbackImpl::Create(
-          resources.release_callbacks[media::VideoFrame::kVPlane]));
+  ResourceId v_resource = u_resource;
+  if (video_frame->format() != media::PIXEL_FORMAT_NV12) {
+    v_resource = resource_provider->CreateResourceFromTextureMailbox(
+        resources.mailboxes[media::VideoFrame::kVPlane],
+        SingleReleaseCallbackImpl::Create(
+            resources.release_callbacks[media::VideoFrame::kVPlane]));
+  }
   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]));
   }
 
   const gfx::Size ya_tex_size = video_frame->coded_size();
   const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize(
       video_frame->format(), media::VideoFrame::kUPlane,
       video_frame->coded_size());
-  DCHECK(uv_tex_size == media::VideoFrame::PlaneSize(
-                            video_frame->format(), media::VideoFrame::kVPlane,
-                            video_frame->coded_size()));
+  if (media::VideoFrame::NumPlanes(video_frame->format()) >
+      media::VideoFrame::kVPlane) {
+    DCHECK(uv_tex_size == media::VideoFrame::PlaneSize(
+                              video_frame->format(), media::VideoFrame::kVPlane,
+                              video_frame->coded_size()));
+  }
   if (with_alpha) {
     DCHECK(ya_tex_size == media::VideoFrame::PlaneSize(
                               video_frame->format(), media::VideoFrame::kAPlane,
                               video_frame->coded_size()));
   }
 
   gfx::RectF ya_tex_coord_rect(tex_coord_rect.x() * ya_tex_size.width(),
                                tex_coord_rect.y() * ya_tex_size.height(),
                                tex_coord_rect.width() * ya_tex_size.width(),
                                tex_coord_rect.height() * ya_tex_size.height());
@@ skipping 190 matching lines @@
   scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
       format, rect.size(), rect, rect.size(), base::TimeDelta());
   video_frame->metadata()->SetInteger(media::VideoFrameMetadata::COLOR_SPACE,
                                       color_space);
 
   // 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));
+  if (format == media::PIXEL_FORMAT_NV12) {
+    uint8_t* data = video_frame->data(media::VideoFrame::kUVPlane);
+    int stride = video_frame->stride(media::VideoFrame::kUVPlane);
+    gfx::Size plane_size = video_frame->PlaneSize(video_frame->format(),
+                                                  media::VideoFrame::kUVPlane,
+                                                  video_frame->coded_size());
+
+    for (int y = 0; y < plane_size.height(); ++y) {
+      for (int x = 0; x < plane_size.width(); ++x) {
+        data[x * 2] = u;
+        data[x * 2 + 1] = v;
+      }
+      data += stride;
+    }
+  } else {
+    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_t alpha_value = is_transparent ? 0 : 128;
   CreateTestYUVVideoDrawQuad_FromVideoFrame(
       shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
       video_resource_updater, rect, visible_rect, resource_provider);
 }
 
 typedef ::testing::Types<GLRenderer,
                          SoftwareRenderer,
                          GLRendererWithExpandedViewport,
@@ skipping 672 matching lines @@
       video_resource_updater_.get(), rect, rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
+TEST_F(VideoGLRendererPixelTest, SimpleNV12JRect) {
+  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::PIXEL_FORMAT_NV12, media::COLOR_SPACE_JPEG, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(),
+      video_resource_updater_.get(), rect, rect, resource_provider_.get());
+
+  RenderPassList pass_list;
+  pass_list.push_back(std::move(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
 // tex coord rect is only a partial subrectangle of the coded contents.
 TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) {
   RenderPassList pass_list;
   CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12, media::COLOR_SPACE_JPEG,
                       &pass_list);
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
@@ skipping 1932 matching lines @@
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc