cc: Add support for non-2D texture targets to YUVVideoQuad.

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 1884 matching lines @@
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   bool use_alpha_plane = quad->a_plane_resource_id != 0;
 
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_, quad->y_plane_resource_id, GL_TEXTURE1, GL_LINEAR);
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), y_plane_lock.target());
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, quad->u_plane_resource_id, GL_TEXTURE2, GL_LINEAR);
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), u_plane_lock.target());
+  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(static_cast<GLenum>(GL_TEXTURE_2D), v_plane_lock.target());
+  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(static_cast<GLenum>(GL_TEXTURE_2D), a_plane_lock->target());
+    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());
+
   int matrix_location = -1;
-  int tex_scale_location = -1;
-  int tex_offset_location = -1;
+  int ya_tex_scale_location = -1;
+  int ya_tex_offset_location = -1;
+  int uv_tex_scale_location = -1;
+  int uv_tex_offset_location = -1;
   int ya_clamp_rect_location = -1;
   int uv_clamp_rect_location = -1;
   int y_texture_location = -1;
   int u_texture_location = -1;
   int v_texture_location = -1;
   int a_texture_location = -1;
   int yuv_matrix_location = -1;
   int yuv_adj_location = -1;
   int alpha_location = -1;
   if (use_alpha_plane) {
-    const VideoYUVAProgram* program = GetVideoYUVAProgram(tex_coord_precision);
+    const VideoYUVAProgram* program =
+        GetVideoYUVAProgram(tex_coord_precision, sampler);
     DCHECK(program && (program->initialized() || IsContextLost()));
     SetUseProgram(program->program());
     matrix_location = program->vertex_shader().matrix_location();
-    tex_scale_location = program->vertex_shader().tex_scale_location();
-    tex_offset_location = program->vertex_shader().tex_offset_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();
     a_texture_location = program->fragment_shader().a_texture_location();

[hendrikw, 2015/05/11 23:22:20]

This if/else is getting long, and only 2 lines differ, should we consider
handling the program and a_texture_location separately?  We wouldn't need all of
the -1's above either then.

[reveman, 2015/05/11 23:35:01]

The program types are different so we'd need add some template function function
to change this. That might be a good idea but I'd rather do that in a separate
patch.

     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 VideoYUVProgram* program = GetVideoYUVProgram(tex_coord_precision);
+    const VideoYUVProgram* program =
+        GetVideoYUVProgram(tex_coord_precision, sampler);
     DCHECK(program && (program->initialized() || IsContextLost()));
     SetUseProgram(program->program());
     matrix_location = program->vertex_shader().matrix_location();
-    tex_scale_location = program->vertex_shader().tex_scale_location();
-    tex_offset_location = program->vertex_shader().tex_offset_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();
   }
 
-  gl_->Uniform2f(tex_scale_location, quad->tex_coord_rect.width(),
-                 quad->tex_coord_rect.height());
-  gl_->Uniform2f(tex_offset_location, quad->tex_coord_rect.x(),
-                 quad->tex_coord_rect.y());
-  // Clamping to half a texel inside the tex coord rect prevents bilinear
-  // filtering from filtering outside the tex coord rect.
-  gfx::RectF ya_clamp_rect(quad->tex_coord_rect);
-  // Special case: empty texture size implies no clamping.
-  if (!quad->ya_tex_size.IsEmpty()) {
-    ya_clamp_rect.Inset(0.5f / quad->ya_tex_size.width(),
-                        0.5f / quad->ya_tex_size.height());
+  gfx::SizeF ya_tex_scale(1, 1);
+  gfx::SizeF uv_tex_scale(1, 1);
+  if (sampler != SAMPLER_TYPE_2D_RECT) {
+    DCHECK(!quad->ya_tex_size.IsEmpty());
+    DCHECK(!quad->uv_tex_size.IsEmpty());
+    ya_tex_scale.Scale(1.0f / quad->ya_tex_size.width(),

[danakj, 2015/05/12 16:32:12]

you're scaling 1 by this, you could just say = gfx::SizeF(1/ya_tex_size,...)
etc? 

[reveman, 2015/05/12 17:09:36]

Done.

+                       1.0f / quad->ya_tex_size.height());
+    uv_tex_scale.Scale(1.0f / quad->uv_tex_size.width(),
+                       1.0f / quad->uv_tex_size.height());
   }
-  gfx::RectF uv_clamp_rect(quad->tex_coord_rect);
-  if (!quad->uv_tex_size.IsEmpty()) {
-    uv_clamp_rect.Inset(0.5f / quad->uv_tex_size.width(),
-                        0.5f / quad->uv_tex_size.height());
-  }
+
+  float ya_vertex_tex_translate_x =
+      quad->ya_tex_coord_rect.x() * ya_tex_scale.width();
+  float ya_vertex_tex_translate_y =
+      quad->ya_tex_coord_rect.y() * ya_tex_scale.height();
+  float ya_vertex_tex_scale_x =
+      quad->ya_tex_coord_rect.width() * ya_tex_scale.width();
+  float ya_vertex_tex_scale_y =
+      quad->ya_tex_coord_rect.height() * ya_tex_scale.height();
+
+  float uv_vertex_tex_translate_x =
+      quad->uv_tex_coord_rect.x() * uv_tex_scale.width();
+  float uv_vertex_tex_translate_y =
+      quad->uv_tex_coord_rect.y() * uv_tex_scale.height();
+  float uv_vertex_tex_scale_x =
+      quad->uv_tex_coord_rect.width() * uv_tex_scale.width();
+  float uv_vertex_tex_scale_y =
+      quad->uv_tex_coord_rect.height() * uv_tex_scale.height();
+
+  gl_->Uniform2f(ya_tex_scale_location, ya_vertex_tex_scale_x,
+                 ya_vertex_tex_scale_y);
+  gl_->Uniform2f(ya_tex_offset_location, ya_vertex_tex_translate_x,
+                 ya_vertex_tex_translate_y);
+  gl_->Uniform2f(uv_tex_scale_location, uv_vertex_tex_scale_x,
+                 uv_vertex_tex_scale_y);
+  gl_->Uniform2f(uv_tex_offset_location, uv_vertex_tex_translate_x,
+                 uv_vertex_tex_translate_y);
+
+  gfx::RectF ya_clamp_rect(ya_vertex_tex_translate_x, ya_vertex_tex_translate_y,
+                           ya_vertex_tex_scale_x, ya_vertex_tex_scale_y);
+  ya_clamp_rect.Inset(0.5f * ya_tex_scale.width(),
+                      0.5f * ya_tex_scale.height());
+  gfx::RectF uv_clamp_rect(uv_vertex_tex_translate_x, uv_vertex_tex_translate_y,
+                           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_alpha_plane)
     gl_->Uniform1i(a_texture_location, 4);
@@ skipping 1264 matching lines @@
   TextureProgram* program = &texture_io_surface_program_[precision];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");
     program->Initialize(output_surface_->context_provider(), precision,
                         SAMPLER_TYPE_2D_RECT);
   }
   return program;
 }
 
 const GLRenderer::VideoYUVProgram* GLRenderer::GetVideoYUVProgram(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
-  VideoYUVProgram* program = &video_yuv_program_[precision];
+  DCHECK_GE(sampler, 0);
+  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_TYPE_2D);
+                        sampler);
   }
   return program;
 }
 
 const GLRenderer::VideoYUVAProgram* GLRenderer::GetVideoYUVAProgram(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
-  VideoYUVAProgram* program = &video_yuva_program_[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");
     program->Initialize(output_surface_->context_provider(), precision,
-                        SAMPLER_TYPE_2D);
+                        sampler);
   }
   return program;
 }
 
 const GLRenderer::VideoStreamTextureProgram*
 GLRenderer::GetVideoStreamTextureProgram(TexCoordPrecision precision) {
   if (!Capabilities().using_egl_image)
     return NULL;
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
@@ skipping 20 matching lines @@
       tile_program_swizzle_aa_[i][j].Cleanup(gl_);
 
       for (int k = 0; k <= LAST_BLEND_MODE; k++) {
         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_);
     }
     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_);
     }
 
     texture_program_[i].Cleanup(gl_);
     nonpremultiplied_texture_program_[i].Cleanup(gl_);
     texture_background_program_[i].Cleanup(gl_);
     nonpremultiplied_texture_background_program_[i].Cleanup(gl_);
     texture_io_surface_program_[i].Cleanup(gl_);
 
-    video_yuv_program_[i].Cleanup(gl_);
-    video_yuva_program_[i].Cleanup(gl_);
     video_stream_texture_program_[i].Cleanup(gl_);
   }
 
   tile_checkerboard_program_.Cleanup(gl_);
 
   debug_border_program_.Cleanup(gl_);
   solid_color_program_.Cleanup(gl_);
   solid_color_program_aa_.Cleanup(gl_);
 
   if (offscreen_framebuffer_id_)
@@ skipping 79 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         ToNearestRect(overlay.display_rect),
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc