Enable sampling from DXGI NV12 formats in GLRenderer.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1947 matching lines @@
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   bool use_alpha_plane = quad->a_plane_resource_id() != 0;
+  bool use_nv12 = quad->v_plane_resource_id() == quad->u_plane_resource_id();
+
+  if (use_nv12 && use_alpha_plane)
+    return;

[danakj, 2016/04/11 23:28:28]

do you mean dcheck?

 
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_, quad->y_plane_resource_id(), GL_TEXTURE1, GL_LINEAR);
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, quad->u_plane_resource_id(), GL_TEXTURE2, GL_LINEAR);
   DCHECK_EQ(y_plane_lock.target(), u_plane_lock.target());
-  ResourceProvider::ScopedSamplerGL v_plane_lock(
-      resource_provider_, quad->v_plane_resource_id(), GL_TEXTURE3, GL_LINEAR);
-  DCHECK_EQ(y_plane_lock.target(), v_plane_lock.target());
+  scoped_ptr<ResourceProvider::ScopedSamplerGL> v_plane_lock;

[danakj, 2016/04/11 23:28:28]

TODO to use base::Optional, no need for mallocs here.

+  if (!use_nv12) {
+    v_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(
+        resource_provider_, quad->v_plane_resource_id(), GL_TEXTURE3,
+        GL_LINEAR));
+    DCHECK_EQ(y_plane_lock.target(), v_plane_lock->target());
+  }
   scoped_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;
   if (use_alpha_plane) {
     a_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(
         resource_provider_, quad->a_plane_resource_id(), GL_TEXTURE4,
         GL_LINEAR));
     DCHECK_EQ(y_plane_lock.target(), a_plane_lock->target());
   }
 
   // All planes must have the same sampler type.
   SamplerType sampler = SamplerTypeFromTextureTarget(y_plane_lock.target());
@@ skipping 26 matching lines @@
     u_texture_location = program->fragment_shader().u_texture_location();
     v_texture_location = program->fragment_shader().v_texture_location();
     a_texture_location = program->fragment_shader().a_texture_location();
     yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
     yuv_adj_location = program->fragment_shader().yuv_adj_location();
     ya_clamp_rect_location =
         program->fragment_shader().ya_clamp_rect_location();
     uv_clamp_rect_location =
         program->fragment_shader().uv_clamp_rect_location();
     alpha_location = program->fragment_shader().alpha_location();
-  } else {
+  } else if (!use_nv12) {
     const VideoYUVProgram* program =
         GetVideoYUVProgram(tex_coord_precision, sampler);
     DCHECK(program && (program->initialized() || IsContextLost()));
     SetUseProgram(program->program());
     matrix_location = program->vertex_shader().matrix_location();
     ya_tex_scale_location = program->vertex_shader().ya_tex_scale_location();
     ya_tex_offset_location = program->vertex_shader().ya_tex_offset_location();
     uv_tex_scale_location = program->vertex_shader().uv_tex_scale_location();
     uv_tex_offset_location = program->vertex_shader().uv_tex_offset_location();
     y_texture_location = program->fragment_shader().y_texture_location();
     u_texture_location = program->fragment_shader().u_texture_location();
     v_texture_location = program->fragment_shader().v_texture_location();
     yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
     yuv_adj_location = program->fragment_shader().yuv_adj_location();
     ya_clamp_rect_location =
         program->fragment_shader().ya_clamp_rect_location();
     uv_clamp_rect_location =
         program->fragment_shader().uv_clamp_rect_location();
     alpha_location = program->fragment_shader().alpha_location();
+  } else {
+    const VideoNV12Program* program =
+        GetVideoNV12Program(tex_coord_precision, sampler);
+    DCHECK(program && (program->initialized() || IsContextLost()));
+    SetUseProgram(program->program());
+    matrix_location = program->vertex_shader().matrix_location();
+    ya_tex_scale_location = program->vertex_shader().ya_tex_scale_location();
+    ya_tex_offset_location = program->vertex_shader().ya_tex_offset_location();
+    uv_tex_scale_location = program->vertex_shader().uv_tex_scale_location();
+    uv_tex_offset_location = program->vertex_shader().uv_tex_offset_location();
+    y_texture_location = program->fragment_shader().y_texture_location();
+    u_texture_location = program->fragment_shader().uv_texture_location();
+    yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
+    yuv_adj_location = program->fragment_shader().yuv_adj_location();
+    ya_clamp_rect_location =
+        program->fragment_shader().ya_clamp_rect_location();
+    uv_clamp_rect_location =
+        program->fragment_shader().uv_clamp_rect_location();
+    alpha_location = program->fragment_shader().alpha_location();
   }
 
   gfx::SizeF ya_tex_scale(1.0f, 1.0f);
   gfx::SizeF uv_tex_scale(1.0f, 1.0f);
   if (sampler != SAMPLER_TYPE_2D_RECT) {
     DCHECK(!quad->ya_tex_size.IsEmpty());
     DCHECK(!quad->uv_tex_size.IsEmpty());
     ya_tex_scale = gfx::SizeF(1.0f / quad->ya_tex_size.width(),
                               1.0f / quad->ya_tex_size.height());
     uv_tex_scale = gfx::SizeF(1.0f / quad->uv_tex_size.width(),
@@ skipping 35 matching lines @@
                            uv_vertex_tex_scale_x, uv_vertex_tex_scale_y);
   uv_clamp_rect.Inset(0.5f * uv_tex_scale.width(),
                       0.5f * uv_tex_scale.height());
   gl_->Uniform4f(ya_clamp_rect_location, ya_clamp_rect.x(), ya_clamp_rect.y(),
                  ya_clamp_rect.right(), ya_clamp_rect.bottom());
   gl_->Uniform4f(uv_clamp_rect_location, uv_clamp_rect.x(), uv_clamp_rect.y(),
                  uv_clamp_rect.right(), uv_clamp_rect.bottom());
 
   gl_->Uniform1i(y_texture_location, 1);
   gl_->Uniform1i(u_texture_location, 2);
-  gl_->Uniform1i(v_texture_location, 3);
+  if (!use_nv12)
+    gl_->Uniform1i(v_texture_location, 3);
   if (use_alpha_plane)
     gl_->Uniform1i(a_texture_location, 4);
 
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
   // http://www.fourcc.org/fccyvrgb.php
   float yuv_to_rgb_rec601[9] = {
       1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
   };
   float yuv_to_rgb_jpeg[9] = {
@@ skipping 1291 matching lines @@
   DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
   VideoYUVProgram* program = &video_yuv_program_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");
     program->Initialize(output_surface_->context_provider(), precision,
                         sampler);
   }
   return program;
 }
 
+const GLRenderer::VideoNV12Program* GLRenderer::GetVideoNV12Program(

[danakj, 2016/04/11 23:28:28]

This program should be tested in our unit tests that cover every shader right?

+    TexCoordPrecision precision,
+    SamplerType sampler) {
+  DCHECK_GE(precision, 0);
+  DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
+  VideoNV12Program* program = &video_nv12_program_[precision][sampler];
+  if (!program->initialized()) {
+    TRACE_EVENT0("cc", "GLRenderer::videoNV12Program::initialize");
+    program->Initialize(output_surface_->context_provider(), precision,
+                        sampler);
+  }
+  return program;
+}
+
 const GLRenderer::VideoYUVAProgram* GLRenderer::GetVideoYUVAProgram(
     TexCoordPrecision precision,
     SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
   DCHECK_GE(sampler, 0);
   DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
   VideoYUVAProgram* program = &video_yuva_program_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVAProgram::initialize");
@@ skipping 33 matching lines @@
         for (int l = 0; l <= LAST_MASK_VALUE; ++l) {
           render_pass_mask_program_[i][j][k][l].Cleanup(gl_);
           render_pass_mask_program_aa_[i][j][k][l].Cleanup(gl_);
           render_pass_mask_color_matrix_program_aa_[i][j][k][l].Cleanup(gl_);
           render_pass_mask_color_matrix_program_[i][j][k][l].Cleanup(gl_);
         }
       }
 
       video_yuv_program_[i][j].Cleanup(gl_);
       video_yuva_program_[i][j].Cleanup(gl_);
+      video_nv12_program_[i][j].Cleanup(gl_);
     }
     for (int j = 0; j <= LAST_BLEND_MODE; j++) {
       render_pass_program_[i][j].Cleanup(gl_);
       render_pass_program_aa_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_aa_[i][j].Cleanup(gl_);
     }
 
     for (int j = 0; j <= LAST_SAMPLER_TYPE; ++j) {
       texture_program_[i][j].Cleanup(gl_);
@@ skipping 126 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc