Fix HTML5 video blurry

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 63 matching lines @@
   gfx::PointF uv0 = quad->uv_top_left;
   gfx::PointF uv1 = quad->uv_bottom_right;
   Float4 xform = {{uv0.x(), uv0.y(), uv1.x() - uv0.x(), uv1.y() - uv0.y()}};
   if (quad->y_flipped) {
     xform.data[1] = 1.0f - xform.data[1];
     xform.data[3] = -xform.data[3];
   }
   return xform;
 }
 
+Float4 UVClampRect(const TextureDrawQuad* quad,
+                   const gfx::Size& texture_size,
+                   SamplerType sampler) {
+  gfx::SizeF half_texel(0.5f, 0.5f);
+  gfx::RectF uv_clamp_rect(quad->uv_top_left.x(), quad->uv_top_left.y(),
+                           quad->uv_bottom_right.x() - quad->uv_top_left.x(),
+                           quad->uv_bottom_right.y() - quad->uv_top_left.y());
+  if (sampler != SAMPLER_TYPE_2D_RECT) {
+    half_texel.Scale(1.f / texture_size.width(), 1.f / texture_size.height());
+  } else {
+    uv_clamp_rect.Scale(texture_size.width(), texture_size.height());
+  }
+  uv_clamp_rect.Inset(half_texel.width(), half_texel.height());
+  return {{uv_clamp_rect.x(), uv_clamp_rect.y(), uv_clamp_rect.right(),
+           uv_clamp_rect.bottom()}};
+}
+
 Float4 PremultipliedColor(SkColor color) {
   const float factor = 1.0f / 255.0f;
   const float alpha = SkColorGetA(color) * factor;
 
   Float4 result = {
       {SkColorGetR(color) * factor * alpha, SkColorGetG(color) * factor * alpha,
        SkColorGetB(color) * factor * alpha, alpha}};
   return result;
 }
 
@@ skipping 2384 matching lines @@
                                           quad->resource_id());
 
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
   gl_->UniformMatrix4fvStreamTextureMatrixCHROMIUM(
       program->vertex_shader().tex_matrix_location(), false, gl_matrix);
 
   gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
 
-  SetShaderOpacity(quad->shared_quad_state->opacity,
-                   program->fragment_shader().alpha_location());
+  // Prevent texture bleeding issue.

[enne (OOO), 2016/10/19 19:04:03]

comment nit: I don't think it's helpful to have this "Prevent texture bleeding
issue" comment anywhere that there's a clamping rect.  I think a comment here
would be useful to say "calculate a half pixel offset from the texture edges for
the shader to use in clamping texture coordinates in order to prevent texture
bleed", since that covers both the "what" and the "why" of this block of code
(which maybe doesn't need to be in a {} block either).

I think the rest of the "prevent texture bleeding issue" comments below can just
be removed.

Also, is there any way to make this block of code reuse the UVClampRect
function?

[dshwang, 2016/10/20 18:57:55]

Done.

+  {
+    gfx::Size texture_size = lock.size();
+    gfx::SizeF half_texel(0.5f / texture_size.width(),
+                          0.5f / texture_size.height());
+    gfx::Vector2dF uv = quad->matrix.Scale2d();
+    gfx::RectF tex_clamp_rect(0, 0, uv.x(), uv.y());
+    tex_clamp_rect.Inset(half_texel.width(), half_texel.height());
+    gl_->Uniform4f(program->fragment_shader().tex_clamp_rect_location(),
+                   tex_clamp_rect.x(), tex_clamp_rect.y(),
+                   tex_clamp_rect.right(), tex_clamp_rect.bottom());
+  }
+
   if (!clip_region) {
     DrawQuadGeometry(frame->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      gfx::RectF(quad->rect),
                      program->vertex_shader().matrix_location());
   } else {
     gfx::QuadF region_quad(*clip_region);
     region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     float uvs[8] = {0};
@@ skipping 22 matching lines @@
   int background_color_location;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
   template <class Program>
   void Set(Program* program) {
     TextureProgramBinding::Set(program);
     tex_transform_location = program->vertex_shader().tex_transform_location();
     vertex_opacity_location =
         program->vertex_shader().vertex_opacity_location();
+    tex_clamp_rect_location =
+        program->fragment_shader().tex_clamp_rect_location();
   }
   int tex_transform_location;
   int vertex_opacity_location;
+  int tex_clamp_rect_location;
 };
 
 void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
   // Check to see if we have anything to draw.
   if (draw_cache_.program_id == -1)
     return;
 
   PrepareGeometry(flush_binding);
 
   // Set the correct blending mode.
@@ skipping 20 matching lines @@
 
   // Upload the tranforms for both points and uvs.
   gl_->UniformMatrix4fv(
       static_cast<int>(draw_cache_.matrix_location),
       static_cast<int>(draw_cache_.matrix_data.size()), false,
       reinterpret_cast<float*>(&draw_cache_.matrix_data.front()));
   gl_->Uniform4fv(static_cast<int>(draw_cache_.uv_xform_location),
                   static_cast<int>(draw_cache_.uv_xform_data.size()),
                   reinterpret_cast<float*>(&draw_cache_.uv_xform_data.front()));
 
+  // Prevent texture bleeding issue.
+  gl_->Uniform4fv(
+      draw_cache_.tex_clamp_rect_location,
+      static_cast<int>(draw_cache_.tex_clamp_rect_data.size()),
+      reinterpret_cast<float*>(&draw_cache_.tex_clamp_rect_data.front()));
+
   if (draw_cache_.background_color != SK_ColorTRANSPARENT) {
     Float4 background_color = PremultipliedColor(draw_cache_.background_color);
     gl_->Uniform4fv(draw_cache_.background_color_location, 1,
                     background_color.data);
   }
 
   gl_->Uniform1fv(
       static_cast<int>(draw_cache_.vertex_opacity_location),
       static_cast<int>(draw_cache_.vertex_opacity_data.size()),
       static_cast<float*>(&draw_cache_.vertex_opacity_data.front()));
@@ skipping 23 matching lines @@
 
     gl_->LineWidth(3.0f);
     // The indices for the line are stored in the same array as the triangle
     // indices.
     gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
   }
 
   // Clear the cache.
   draw_cache_.program_id = -1;
   draw_cache_.uv_xform_data.resize(0);
+  draw_cache_.tex_clamp_rect_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 
   // If we had a clipped binding, prepare the shared binding for the
   // next inserts.
   if (flush_binding == CLIPPED_BINDING) {
     PrepareGeometry(SHARED_BINDING);
   }
 }
 
@@ skipping 44 matching lines @@
       draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= max_quads) {
     FlushTextureQuadCache(SHARED_BINDING);
     draw_cache_.program_id = binding.program_id;
     draw_cache_.resource_id = resource_id;
     draw_cache_.needs_blending = quad->ShouldDrawWithBlending();
     draw_cache_.nearest_neighbor = quad->nearest_neighbor;
     draw_cache_.background_color = quad->background_color;
 
     draw_cache_.uv_xform_location = binding.tex_transform_location;
+    draw_cache_.tex_clamp_rect_location = binding.tex_clamp_rect_location;
     draw_cache_.background_color_location = binding.background_color_location;
     draw_cache_.vertex_opacity_location = binding.vertex_opacity_location;
     draw_cache_.matrix_location = binding.matrix_location;
     draw_cache_.sampler_location = binding.sampler_location;
   }
 
   // Generate the uv-transform
   Float4 uv_transform = {{0.0f, 0.0f, 1.0f, 1.0f}};
   if (!clip_region)
     uv_transform = UVTransform(quad);
   if (sampler == SAMPLER_TYPE_2D_RECT) {
     // Un-normalize the texture coordiantes for rectangle targets.
     gfx::Size texture_size = lock.size();
     uv_transform.data[0] *= texture_size.width();
     uv_transform.data[2] *= texture_size.width();
     uv_transform.data[1] *= texture_size.height();
     uv_transform.data[3] *= texture_size.height();
   }
   draw_cache_.uv_xform_data.push_back(uv_transform);
 
+  // Prevent texture bleeding issue.
+  if (draw_cache_.tex_clamp_rect_location != -1) {
+    // VideoLayerImpl always set background color to transparent.
+    DCHECK(quad->background_color == SK_ColorTRANSPARENT);
+    gfx::Size texture_size = lock.size();
+    if (texture_size.IsEmpty()) {
+      // TODO(dshwang): correct all code coming to here. crbug.com/615325
+      texture_size = quad->rect.size();
+    }
+    Float4 tex_clamp_rect = UVClampRect(quad, texture_size, sampler);
+    draw_cache_.tex_clamp_rect_data.push_back(tex_clamp_rect);

[enne (OOO), 2016/10/19 19:04:03]

This is a bit odd.  I think that draw_cache_'s vectors are intended to be
parallel vectors, and if you had another texture quad before this without a
clamp rect, then this would get coalesced incorrectly.

For what it's worth, the texture draw quad queue is an optimization to allow
coalescing of texture quads that share the same texture (and other things).  I
don't think we need to support batching for this case, so maybe just always
flush the cache if there's a tex clamp rect and only store one of them?

Does that make sense?

[dshwang, 2016/10/20 18:57:55]

I don't understand why you think this would get coalesced incorrectly?

|tex_clamp_rect| is used in fragment shader to pick sampling point up for
bilinear filter. It juse affects edge of each tex quad slightly. As we can
coalesce several quads, we can also coalesce several quads with slight boarder
change.

In another words, draw_cache_.tex_clamp_rect_data is similar type of data to
draw_cache_.uv_xform_data as both affect glsl attributes per quad.

In addition, the same video texture (i.e. VideoFrame) can be rendered multiple
times. e.g. reflect filter, WebRTC has one stream but binds it to multiple
<video> elements.

Please advise me if I'm wrong.

+  }
+
   // Generate the vertex opacity
   const float opacity = quad->shared_quad_state->opacity;
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
@@ skipping 1332 matching lines @@
 
   gl_->ScheduleCALayerSharedStateCHROMIUM(
       ca_layer_overlay->shared_state->opacity, is_clipped, clip_rect,
       sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc