Increase YUV video clamping

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 1986 matching lines @@
     locations->original_backdrop = original_backdrop_location();
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1),
-      clamp_rect_location_(-1) {
+      ya_clamp_rect_location_(-1),
+      uv_clamp_rect_location_(-1) {
 }
 
 void FragmentShaderYUVVideo::Init(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {"y_texture",
                                    "u_texture",
                                    "v_texture",
                                    "alpha",
                                    "yuv_matrix",
                                    "yuv_adj",
-                                   "clamp_rect"};
+                                   "ya_clamp_rect",
+                                   "uv_clamp_rect"};
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   y_texture_location_ = locations[0];
   u_texture_location_ = locations[1];
   v_texture_location_ = locations[2];
   alpha_location_ = locations[3];
   yuv_matrix_location_ = locations[4];
   yuv_adj_location_ = locations[5];
-  clamp_rect_location_ = locations[6];
+  ya_clamp_rect_location_ = locations[6];
+  uv_clamp_rect_location_ = locations[7];
 }
 
 std::string FragmentShaderYUVVideo::GetShaderString(TexCoordPrecision precision,
                                                     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderYUVVideo::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType y_texture;
     uniform SamplerType u_texture;
     uniform SamplerType v_texture;
     uniform float alpha;
     uniform vec3 yuv_adj;
     uniform mat3 yuv_matrix;
-    uniform vec4 clamp_rect;
+    uniform vec4 ya_clamp_rect;
+    uniform vec4 uv_clamp_rect;
   });
 }
 
 std::string FragmentShaderYUVVideo::GetShaderBody() {
   return SHADER0([]() {
     void main() {
-      vec2 clamped = max(clamp_rect.xy, min(clamp_rect.zw, v_texCoord));
-      float y_raw = TextureLookup(y_texture, clamped).x;
-      float u_unsigned = TextureLookup(u_texture, clamped).x;
-      float v_unsigned = TextureLookup(v_texture, clamped).x;
+      vec2 ya_clamped =
+          max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_texCoord));
+      float y_raw = TextureLookup(y_texture, ya_clamped).x;
+      vec2 uv_clamped =
+          max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_texCoord));
+      float u_unsigned = TextureLookup(u_texture, uv_clamped).x;
+      float v_unsigned = TextureLookup(v_texture, uv_clamped).x;
       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
       vec3 rgb = yuv_matrix * yuv;
       gl_FragColor = vec4(rgb, 1.0) * alpha;
     }
   });
 }
 
 FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       a_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1) {
 }
 
 void FragmentShaderYUVAVideo::Init(GLES2Interface* context,
                                    unsigned program,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "a_texture",
       "alpha",
       "cc_matrix",
       "yuv_adj",
-      "clamp_rect",
+      "ya_clamp_rect",
+      "uv_clamp_rect",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   y_texture_location_ = locations[0];
   u_texture_location_ = locations[1];
   v_texture_location_ = locations[2];
   a_texture_location_ = locations[3];
   alpha_location_ = locations[4];
   yuv_matrix_location_ = locations[5];
   yuv_adj_location_ = locations[6];
-  clamp_rect_location_ = locations[7];
+  ya_clamp_rect_location_ = locations[7];
+  uv_clamp_rect_location_ = locations[8];
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType y_texture;
     uniform SamplerType u_texture;
     uniform SamplerType v_texture;
     uniform SamplerType a_texture;
     uniform float alpha;
     uniform vec3 yuv_adj;
     uniform mat3 yuv_matrix;
-    uniform vec4 clamp_rect;
+    uniform vec4 ya_clamp_rect;
+    uniform vec4 uv_clamp_rect;
   });
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderBody() {
   return SHADER0([]() {
     void main() {
-      vec2 clamped = max(clamp_rect.xy, min(clamp_rect.zw, v_texCoord));
-      float y_raw = TextureLookup(y_texture, clamped).x;
-      float u_unsigned = TextureLookup(u_texture, clamped).x;
-      float v_unsigned = TextureLookup(v_texture, clamped).x;
-      float a_raw = TextureLookup(a_texture, clamped).x;
+      vec2 ya_clamped =
+          max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_texCoord));
+      float y_raw = TextureLookup(y_texture, ya_clamped).x;
+      vec2 uv_clamped =
+          max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_texCoord));
+      float u_unsigned = TextureLookup(u_texture, uv_clamped).x;
+      float v_unsigned = TextureLookup(v_texture, uv_clamped).x;
+      float a_raw = TextureLookup(a_texture, ya_clamped).x;
       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
       vec3 rgb = yuv_matrix * yuv;
       gl_FragColor = vec4(rgb, 1.0) * (alpha * a_raw);
     }
   });
 }
 
 FragmentShaderColor::FragmentShaderColor() : color_location_(-1) {
 }
 
@@ skipping 130 matching lines @@
       vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
       vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
       float picker = abs(coord.x - coord.y);  // NOLINT
       gl_FragColor = mix(color1, color2, picker) * alpha;
     }
   });
 }
 
 }  // namespace cc