Fix HTML5 video blurry

cc/output/shader.cc

 // Copyright 2011 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/shader.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 333 matching lines @@
 
 std::string VertexShaderPosTexTransform::GetShaderHead() {
   return SHADER0([]() {
     attribute vec4 a_position;
     attribute TexCoordPrecision vec2 a_texCoord;
     attribute float a_index;
     uniform mat4 matrix[NUM_STATIC_QUADS];
     uniform TexCoordPrecision vec4 texTransform[NUM_STATIC_QUADS];
     uniform float opacity[NUM_STATIC_QUADS * 4];
     varying TexCoordPrecision vec2 v_texCoord;
+    varying float v_index;
     varying float v_alpha;
   });
 }
 
 std::string VertexShaderPosTexTransform::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       int quad_index = int(a_index * 0.25);  // NOLINT
+      v_index = float(quad_index);
       gl_Position = matrix[quad_index] * a_position;
       TexCoordPrecision vec4 texTrans = texTransform[quad_index];
       v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
       v_alpha = opacity[int(a_index)];  // NOLINT
     }
   });
 }
 
 void VertexShaderPosTexTransform::FillLocations(
     ShaderLocations* locations) const {
@@ skipping 837 matching lines @@
 void FragmentShaderRGBATexColorMatrixAlpha::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->color_matrix = color_matrix_location();
   locations->color_offset = color_offset_location();
   locations->backdrop = backdrop_location();
   locations->backdrop_rect = backdrop_rect_location();
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString(
+int FragmentTexQuadBase::background_color_location() const {
+  return -1;
+}
+
+int FragmentTexQuadBase::tex_clamp_rect_location() const {

[dshwang, 2016/10/21 13:26:21]

When TextureQuad has background color, this location is always -1, because
FragmentTexBackgroundBinding doesn't implement it.

+  return -1;
+}
+
+void FragmentTexClampBinding::Init(GLES2Interface* context,
+                                   unsigned program,
+                                   int* base_uniform_index) {
+  static const char* uniforms[] = {
+      "s_texture", "tex_clamp_rect",
+  };
+  int locations[arraysize(uniforms)];
+
+  GetProgramUniformLocations(context, program, arraysize(uniforms), uniforms,
+                             locations, base_uniform_index);
+
+  sampler_location_ = locations[0];
+  DCHECK_NE(sampler_location_, -1);
+
+  tex_clamp_rect_location_ = locations[1];
+  DCHECK_NE(tex_clamp_rect_location_, -1);
+}
+
+int FragmentTexClampBinding::tex_clamp_rect_location() const {
+  return tex_clamp_rect_location_;
+}
+
+std::string FragmentShaderRGBATexClampVaryingAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderHead() {
-  return SHADER0([]() {
-    precision mediump float;
-    varying TexCoordPrecision vec2 v_texCoord;
-    varying float v_alpha;
-    uniform SamplerType s_texture;
-  });
+std::string FragmentShaderRGBATexClampVaryingAlpha::GetShaderHead() {
+  return base::StringPrintf("#define NUM_STATIC_QUADS %d\n",
+                            StaticGeometryBinding::NUM_QUADS) +
+         SHADER0([]() {
+           precision mediump float;
+           varying TexCoordPrecision vec2 v_texCoord;
+           varying float v_index;
+           varying float v_alpha;
+           uniform SamplerType s_texture;
+           uniform vec4 tex_clamp_rect[NUM_STATIC_QUADS];
+         });
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderBody() {
+std::string FragmentShaderRGBATexClampVaryingAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
-      vec4 texColor = TextureLookup(s_texture, v_texCoord);
+      vec2 tex_clamped = max(tex_clamp_rect[int(v_index)].xy,
+                             min(tex_clamp_rect[int(v_index)].zw, v_texCoord));
+      vec4 texColor = TextureLookup(s_texture, tex_clamped);
       gl_FragColor = texColor * v_alpha;
     }
   });
 }
 
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderString(
+std::string FragmentShaderRGBATexClampPremultiplyAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderHead() {
-  return SHADER0([]() {
-    precision mediump float;
-    varying TexCoordPrecision vec2 v_texCoord;
-    varying float v_alpha;
-    uniform SamplerType s_texture;
-  });
+std::string FragmentShaderRGBATexClampPremultiplyAlpha::GetShaderHead() {
+  return base::StringPrintf("#define NUM_STATIC_QUADS %d\n",
+                            StaticGeometryBinding::NUM_QUADS) +
+         SHADER0([]() {
+           precision mediump float;
+           varying TexCoordPrecision vec2 v_texCoord;
+           varying float v_index;
+           varying float v_alpha;
+           uniform SamplerType s_texture;
+           uniform vec4 tex_clamp_rect[NUM_STATIC_QUADS];
+         });
 }
 
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderBody() {
+std::string FragmentShaderRGBATexClampPremultiplyAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
-      vec4 texColor = TextureLookup(s_texture, v_texCoord);
+      vec2 tex_clamped = max(tex_clamp_rect[int(v_index)].xy,
+                             min(tex_clamp_rect[int(v_index)].zw, v_texCoord));
+      vec4 texColor = TextureLookup(s_texture, tex_clamped);
       texColor.rgb *= texColor.a;
       gl_FragColor = texColor * v_alpha;
     }
   });
 }
 
+std::string FragmentShaderRGBATexClamp::GetShaderString(
+    TexCoordPrecision precision,
+    SamplerType sampler) const {
+  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
+}
+
+std::string FragmentShaderRGBATexClamp::GetShaderHead() {
+  return SHADER0([]() {
+    precision mediump float;
+    varying TexCoordPrecision vec2 v_texCoord;
+    uniform SamplerType s_texture;
+    uniform vec4 tex_clamp_rect;
+  });
+}
+
+std::string FragmentShaderRGBATexClamp::GetShaderBody() {
+  return SHADER0([]() {
+    void main() {
+      vec2 tex_clamped =
+          max(tex_clamp_rect.xy, min(tex_clamp_rect.zw, v_texCoord));
+      gl_FragColor = TextureLookup(s_texture, tex_clamped);
+    }
+  });
+}
+
 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
-    : background_color_location_(-1), sampler_location_(-1) {
-}
+    : background_color_location_(-1) {}
 
 void FragmentTexBackgroundBinding::Init(GLES2Interface* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
       "s_texture", "background_color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
 
   sampler_location_ = locations[0];
   DCHECK_NE(sampler_location_, -1);
 
   background_color_location_ = locations[1];
   DCHECK_NE(background_color_location_, -1);
 }
 
+int FragmentTexBackgroundBinding::background_color_location() const {
+  return background_color_location_;
+}
+
 std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
@@ skipping 56 matching lines @@
 
 std::string FragmentShaderRGBATexOpaque::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = vec4(texColor.rgb, 1.0);
     }
   });
 }
 
-std::string FragmentShaderRGBATex::GetShaderString(TexCoordPrecision precision,
-                                                   SamplerType sampler) const {
-  return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
-}
-
-std::string FragmentShaderRGBATex::GetShaderHead() {
-  return SHADER0([]() {
-    precision mediump float;
-    varying TexCoordPrecision vec2 v_texCoord;
-    uniform SamplerType s_texture;
-  });
-}
-
-std::string FragmentShaderRGBATex::GetShaderBody() {
-  return SHADER0([]() {
-    void main() { gl_FragColor = TextureLookup(s_texture, v_texCoord); }
-  });
-}
-
 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
@@ skipping 853 matching lines @@
     void main() {
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = color * aa;
     }
   });
 }
 
 }  // namespace cc